python线程中join（）的用途是什么

Question

我正在研究python线程并遇到了join()。作者告诉我，如果线程处于守护程序模式，那么我需要使用它，join()以便线程可以在主线程终止之前完成自身。但我也看到他用t.join()，即使t不daemon示例代码是这个import threadingimport timeimport logginglogging.basicConfig(level=logging.DEBUG,                    format='(%(threadName)-10s) %(message)s',                    )def daemon():    logging.debug('Starting')    time.sleep(2)    logging.debug('Exiting')d = threading.Thread(name='daemon', target=daemon)d.setDaemon(True)def non_daemon():    logging.debug('Starting')    logging.debug('Exiting')t = threading.Thread(name='non-daemon', target=non_daemon)d.start()t.start()d.join()t.join()我不知道这是什么用途，t.join()因为它不是守护程序，即使删除它也看不到任何变化

Answer 1

展示这种机制的技术有些笨拙：join()大概是由主线程调用的。也可以由另一个线程调用它，但是会不必要地使该图复杂化。

join调用应该放在主线程的轨道上，但是为了表达线程关系并使它尽可能简单，我选择将其放在子线程中。

without join:

+---+---+------------------                     main-thread

    |   |

    |   +...........                            child-thread(short)

    +..................................         child-thread(long)

with join

+---+---+------------------***********+###      main-thread

    |   |                             |

    |   +...........join()            |         child-thread(short)

    +......................join()......         child-thread(long)

with join and daemon thread

+-+--+---+------------------***********+###     parent-thread

  |  |   |                             |

  |  |   +...........join()            |        child-thread(short)

  |  +......................join()......        child-thread(long)

  +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,     child-thread(long + daemonized)

'-' main-thread/parent-thread/main-program execution

'.' child-thread execution

'#' optional parent-thread execution after join()-blocked parent-thread could 

    continue

'*' main-thread 'sleeping' in join-method, waiting for child-thread to finish

',' daemonized thread - 'ignores' lifetime of other threads;

    terminates when main-programs exits; is normally meant for 

    join-independent tasks

因此，您看不到任何更改的原因是因为您的主线程在之后没有执行任何操作join。您可以说join（仅）与主线程的执行流程相关。

例如，如果您要同时下载一堆页面以将它们串联成一个大页面，则可以使用线程开始并发下载，但是需要等到最后一页/线程完成后才能开始组装单个页面在很多。那是您使用的时间join()。

Answer 2

直接来自文档

join（[timeout]）等待线程终止。这将阻塞调用线程，直到被调用join（）方法的线程终止（正常或通过未处理的异常终止），或直到发生可选的超时为止。

这意味着，滋生主线程t和d，等待t完成，直到它完成。

根据您的程序采用的逻辑，您可能要等到线程完成后再继续主线程。

另外从文档：

线程可以标记为“守护程序线程”。该标志的重要性在于，仅保留守护程序线程时，整个Python程序都会退出。

一个简单的例子，说我们有这个：

def non_daemon():

    time.sleep(5)

    print 'Test non-daemon'

t = threading.Thread(name='non-daemon', target=non_daemon)

t.start()

结束于：

print 'Test one'

t.join()

print 'Test two'

这将输出：

Test one

Test non-daemon

Test two

在这里，主线程显式等待t线程完成，直到print第二次调用为止。

或者，如果我们有这个：

print 'Test one'

print 'Test two'

t.join()

我们将得到以下输出：

Test one

Test two

Test non-daemon

在这里，我们在主线程中完成工作，然后等待t线程完成。在这种情况下，我们甚至可以删除显式连接t.join()，并且程序将隐式等待t完成。

Answer 3

感谢您提供此主题-它对我也有很大帮助。

我今天学到了有关.join（）的知识。

这些线程并行运行：

d.start()

t.start()

d.join()

t.join()

这些依次运行（不是我想要的）：

d.start()

d.join()

t.start()

t.join()

特别是，我试图变得聪明和整洁：

class Kiki(threading.Thread):

    def __init__(self, time):

        super(Kiki, self).__init__()

        self.time = time

        self.start()

        self.join()

这可行！但是它顺序运行。我可以将self.start（）放在__ init __中，但是不能将self.join（）放入。必须在每个线程启动后执行此操作。

join（）是导致主线程等待线程完成的原因。否则，您的线程将独自运行。

因此，有一种方法可以将join（）视为主线程上的“保留”对象-它可以对线程进行解线程，并在主线程可以继续之前在主线程中按顺序执行。它可以确保您的线程在主线程向前移动之前是完整的。请注意，这意味着在调用join（）之前线程已经完成是可以的-在调用join（）时立即立即释放主线程。

实际上，我现在刚想到，主线程在d.join（）上等待，直到线程d完成，然后才移至t.join（）。

实际上，非常清楚，请考虑以下代码：

import threading

import time

class Kiki(threading.Thread):

    def __init__(self, time):

        super(Kiki, self).__init__()

        self.time = time

        self.start()

    def run(self):

        print self.time, " seconds start!"

        for i in range(0,self.time):

            time.sleep(1)

            print "1 sec of ", self.time

        print self.time, " seconds finished!"

t1 = Kiki(3)

t2 = Kiki(2)

t3 = Kiki(1)

t1.join()

print "t1.join() finished"

t2.join()

print "t2.join() finished"

t3.join()

print "t3.join() finished"

它产生此输出（请注意print语句如何彼此穿线。）

$ python test_thread.py

32   seconds start! seconds start!1

 seconds start!

1 sec of  1

 1 sec of 1  seconds finished!

 21 sec of

3

1 sec of  3

1 sec of  2

2  seconds finished!

1 sec of  3

3  seconds finished!

t1.join() finished

t2.join() finished

t3.join() finished

$ 

t1.join（）正在阻止主线程。所有三个线程在t1.join（）完成之前完成，并且主线程继续执行打印，然后执行t2.join（）然后打印，然后执行t3.join（）然后打印。

欢迎更正。我也是线程新手。

（注意：如果您有兴趣，我正在为DrinkBot编写代码，并且我需要线程来同时运行配料泵，而不是顺序运行-等待每个饮料的时间更少。）