在python線程中使用join（）有什麼用途

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藝術來演示的機制： join()大概是由主線程調用。它也可以被另一個線程調用，但是會不必要地使圖變複雜。

join -alling應放置在主線程的軌道上，但爲了表達線程關係並儘可能保持簡單，我選擇將它放在子線程中。

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 demon thread 
+-+--+---+------------------***********+###  parent-thread 
    | | |        | 
    | | +...........join()   |  child-thread(short) 
    | +......................join()......  child-thread(long) 
    +,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,  child-thread(long+demonized) 

'-' 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 
',' demonized thread - 'ignores' lifetime of other threads; 
    terminates when main-programs exits; is normally meant for 
    join-independent tasks 

所以你看不到任何改動的原因是因爲你的主線程您join後什麼都不做。 您可以說join（僅）與主線程的執行流程相關。

例如，如果您想同時下載一堆頁面以將它們連接成一個大頁面，則可以使用線程啓動併發下載，但需要等到最後一頁/線程完成後再啓動彙集了許多單頁。那時你使用join()。

Answer 2

方法連接（）

會阻塞調用線程，直到調用join（）方法的線程終止。

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

Answer 3

直從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線程完成，直到我t第二次撥打print。

或者，如果我們有這樣的：

print 'Test one' 
print 'Test two' 
t.join() 

我們會得到這樣的輸出：

Test one 
Test two 
Test non-daemon 

在這裏，我們做我們的工作在主線程，然後我們等待t線程完成。在這種情況下，我們甚至可能會刪除顯式加入t.join()，程序將隱式等待t完成。

Answer 4

當爲非守護進程線程和守護進程線程建立連接（t）函數時，主線程（或主進程）應該等待t秒，然後才能進一步處理它自己的進程。在t秒的等待時間內，兩個子線程都應該做他們可以做的事情，比如打印一些文本。在t秒之後，如果非守護線程仍然沒有完成它的工作，並且在主進程完成它的工作後它仍然可以完成它，但是對於守護進程線程，它只是錯過了它的機會性窗口。但是它會在python程序退出後最終死掉。如果有什麼問題，請糾正我。

Answer 5

「使用join（）有什麼用？」你說。真的，它與「關閉文件有什麼關係，因爲當我的程序退出時，python和操作系統會爲我關閉文件」。

這只是一個好的編程問題。您應該在代碼中加入（）您的線程，線程應該而不是正在運行，要麼是因爲您肯定必須確保線程沒有運行來干擾您自己的代碼，或者您想要正確行爲在一個更大的系統中。

僅僅因爲join（）需要額外的時間，你可能會說「我不想讓我的代碼延遲給出答案」。在某些情況下，這可能是完全有效的，但是現在需要考慮到您的代碼「正在爲python和操作系統清理乾淨」。如果您出於性能原因這樣做，我強烈建議您記錄該行爲。如果您正在構建其他人需要使用的庫/軟件包，則尤其如此。

沒有理由不加入（），除了性能方面的原因，我認爲你的代碼不需要執行那麼好。

Answer 6

感謝這個主題 - 它也幫了我很多。

今天我學到了一些關於.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() 

This Works！但它按順序運行。我可以將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" 

它產生這樣的輸出

$ 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，我需要線程運行成分同時泵而不是按順序 - 更少的時間來等待每次喝。）