Question

我正在研究python线程并遇到join()。

作者告诉我，如果线程处于守护进程模式，那么我需要使用join()，这样线程就可以在主线程终止之前自行完成。

但即使t.join()不是t

，我也看到他使用daemon

示例代码就是这个

import threading
import time
import logging

logging.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

有点笨拙的ascii-art来展示机制： 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

直接从docs

加入（[超时]）等到线程终止。这将阻塞调用线程，直到调用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（）视为主线程上的“hold” - 它可以在主线程可以继续之前对线程进行解线程并在主线程中按顺序执行。它确保在主线程向前移动之前完成线程。请注意，这意味着如果您的线程在调用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（）完成之前完成，主线程继续执行print然后t2.join（）然后打印然后t3.join（）然后打印。

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

（注意：如果您感兴趣，我正在为DrinkBot编写代码，我需要同时运行配料泵而不是顺序运行 - 减少等待每种饮料的时间。）

Answer 4

方法join（）

阻塞调用线程，直到调用其join（）方法的线程终止。

来源：http://docs.python.org/2/library/threading.html

Answer 5

当为非守护程序线程和守护程序线程创建join(t)函数时，主线程（或主进程）应等待t秒，然后可以继续处理自己的进程。在t秒等待时间内，两个子线程都应该执行它们可以执行的操作，例如打印出一些文本。在t秒之后，如果非守护程序线程仍未完成其作业，并且它仍然可以在主进程完成其作业后完成它，但对于守护程序线程，它只是错过了它的机会窗口。但是，它会在python程序退出后最终死亡。如果出现问题，请纠正我。

Answer 6

在python 3.x中，join（）用于将线程与主线程连接，即，当join（）用于特定线程时，主线程将停止执行，直到连接的线程执行完毕。

#1 - Without Join():
import threading
import time
def loiter():
    print('You are loitering!')
    time.sleep(5)
    print('You are not loitering anymore!')

t1 = threading.Thread(target = loiter)
t1.start()
print('Hey, I do not want to loiter!')
'''
Output without join()--> 
You are loitering!
Hey, I do not want to loiter!
You are not loitering anymore! #After 5 seconds --> This statement will be printed

'''
#2 - With Join():
import threading
import time
def loiter():
    print('You are loitering!')
    time.sleep(5)
    print('You are not loitering anymore!')

t1 = threading.Thread(target = loiter)
t1.start()
t1.join()
print('Hey, I do not want to loiter!')

'''
Output with join() -->
You are loitering!
You are not loitering anymore! #After 5 seconds --> This statement will be printed
Hey, I do not want to loiter! 

'''

Answer 7

简单理解

具有连接-解释器将等待，直到您的过程完成或终止

>>> from threading import Thread
>>> import time
>>> def sam():
...   print 'started'
...   time.sleep(10)
...   print 'waiting for 10sec'
... 
>>> t = Thread(target=sam)
>>> t.start()
started

>>> t.join() # with join interpreter will wait until your process get completed or terminated
done?   # this line printed after thread execution stopped i.e after 10sec
waiting for 10sec
>>> done?

不加入-解释器不会等到进程终止，

>>> t = Thread(target=sam)
>>> t.start()
started
>>> print 'yes done' #without join interpreter wont wait until process get terminated
yes done
>>> waiting for 10sec

Answer 8

此示例演示了.join()动作：

import threading
import time

def threaded_worker():
    for r in range(10):
        print('Other: ', r)
        time.sleep(2)

thread_ = threading.Timer(1, threaded_worker)
thread_.daemon = True  # If the main thread kills, this thread will be killed too. 
thread_.start()

flag = True

for i in range(10):
    print('Main: ', i)
    time.sleep(2)
    if flag and i > 4:
        print(
            '''
            Threaded_worker() joined to the main thread. 
            Now we have a sequential behavior instead of concurrency.
            ''')
        thread_.join()
        flag = False

出局：

Main:  0
Other:  0
Main:  1
Other:  1
Main:  2
Other:  2
Main:  3
Other:  3
Main:  4
Other:  4
Main:  5
Other:  5

            Threaded_worker() joined to the main thread. 
            Now we have a sequential behavior instead of concurrency.

Other:  6
Other:  7
Other:  8
Other:  9
Main:  6
Main:  7
Main:  8
Main:  9

Answer 9

主线程（或任何其他线程）加入其他线程的原因有很多

线程可能已经创建或持有（锁定）某些资源。加入调用线程可以代表它清除资源
join（）是自然的阻塞调用，用于在被调用线程终止之后继续继续调用join-calling线程。

如果python程序未加入其他线程，则python解释器仍将代表其加入非守护程序线程。

Answer 10

“使用join（）有什么用？”你说。真的，它的答案与“关闭文件有什么用，因为python和操作系统会在我的程序退出时关闭我的文件？”。

这只是一个好的编程问题。你应该在线程不运行的代码中加入（）线程，因为你必须确保线程没有运行以干扰你自己的代码，或者那个你想在更大的系统中正确行事。

您可能会说“我不希望我的代码延迟给出答案”，这只是因为join（）可能需要额外的时间。在某些情况下，这可能是完全有效的，但是您现在需要考虑到您的代码是“让python和操作系统清理”。如果出于性能原因这样做，我强烈建议您记录该行为。如果您正在构建其他人希望使用的库/包，则尤其如此。

除了性能原因之外，没有理由不加入（），我认为你的代码不需要执行。

在python线程中使用join（）有什么用处

10 个答案: