1. python多線程中為什麼要用for遍歷所有線程然後依次調用join

join 主要用於進程/線程之間的協同，其功能在於等待目的進程/線程執行完畢。
在此，因為你的線程操作很簡單，功能函數執行完成後線程就結束了。join與否就顯得區別不大。

2. Python中threading的join和setDaemon的區別及用法

上海藍盟為你解答：

Python多線程編程時，經常會用到join()和setDaemon()方法，今天特地研究了一下兩者的區別。

1、join ()方法：主線程A中，創建了子線程B，並且在主線程A中調用了B.join()，那麼，主線程A會在調用的地方等待，直到子線程B完成操作後，才可以接著往下執行，那麼在調用這個線程時可以使用被調用線程的join方法。

原型：join([timeout]) 裡面的參數時可選的，代表線程運行的最大時間，即如果超過這個時間，不管這個此線程有沒有執行完畢都會被回收，然後主線程或函數都會接著執行的。
例子：

[python] view plain
import threading
import time
class MyThread(threading.Thread):
def __init__(self,id):
threading.Thread.__init__(self)
self.id = id
def run(self):
x = 0
time.sleep(10)
print self.id

if __name__ == "__main__":
t1=MyThread(999)
t1.start()
for i in range(5):
print i
執行後的結果是：

[python] view plain
0
1
2
3
4
999
機器上運行時，4和999之間，有明顯的停頓。解釋：線程t1 start後，主線程並沒有等線程t1運行結束後再執行，而是先把5次循環列印執行完畢（列印到4），然後sleep（10）後，線程t1把傳進去的999才列印出來。
現在，我們把join()方法加進去(其他代碼不變)，看看有什麼不一樣，例子：

[python] view plain
import threading
import time
class MyThread(threading.Thread):
def __init__(self,id):
threading.Thread.__init__(self)
self.id = id
def run(self):
x = 0
time.sleep(10)
print self.id

if __name__ == "__main__":
t1=MyThread(999)
t1.start()
t1.join()
for i in range(5):
print i
執行後的結果是：

[python] view plain
999
0
1
2
3
4
機器上運行時，999之前，有明顯的停頓。解釋：線程t1 start後，主線程停在了join()方法處，等sleep（10）後，線程t1操作結束被join，接著，主線程繼續循環列印。

2、setDaemon()方法。主線程A中，創建了子線程B，並且在主線程A中調用了B.setDaemon(),這個的意思是，把主線程A設置為守護線程，這時候，要是主線程A執行結束了，就不管子線程B是否完成,一並和主線程A退出.這就是setDaemon方法的含義，這基本和join是相反的。此外，還有個要特別注意的：必須在start() 方法調用之前設置，如果不設置為守護線程，程序會被無限掛起。

例子：就是設置子線程隨主線程的結束而結束：

[python] view plain
import threading
import time
class MyThread(threading.Thread):
def __init__(self,id):
threading.Thread.__init__(self)
def run(self):
time.sleep(5)
print "This is " + self.getName()

if __name__ == "__main__":
t1=MyThread(999)
t1.setDaemon(True)
t1.start()
print "I am the father thread."

執行後的結果是：

[python] view plain
I am the father thread.

可以看出，子線程t1中的內容並未打出。解釋：t1.setDaemon(True)的操作，將父線程設置為了守護線程。根據setDaemon()方法的含義，父線程列印內容後便結束了，不管子線程是否執行完畢了。

程序運行中，執行一個主線程，如果主線程又創建一個子線程，主線程和子線程就分兵兩路，分別運行，那麼當主線程完成想退出時，會檢驗子線程是否完成。如果子線程未完成，則主線程會等待子線程完成後再退出。但是有時候我們需要的是，只要主線程完成了，不管子線程是否完成，都要和主線程一起退出，這時就可以用setDaemon方法了。
所以，join和setDaemon的區別如上述的例子，它們基本是相反的。

3. 如何在python多線程join掛起後還能在主線程

join():用線程對象調用，如果在一個線程A中調用另一個線程B的join方法，線程A將會等待線程B執行完畢後再執行。
光看這句話或許還沒有特別明白，沒有給出例子，這篇博文就用例子的形式介紹下這個函數的作用。

4. 一個關於Python多線程的新手問題

用threading模塊的join函數可以檢測線程是否結束

如果只能用thread模塊,可以使用標志位,不過效率比較低,代碼風格也不好

這個相當於自旋鎖

fromtimeimportsleep,ctime
importthread

defloop0(sign):
print'startloop0at:',ctime()
sleep(4)
print'loop0doneat:',ctime()
sign[0]=True

defloop1(sign):
print'startloop1at:',ctime()
sleep(2)
print'loop1doneat:',ctime()
sign[1]=True

defmain():
print'startingat:',ctime()
sign=[False,False]
thread.start_new_thread(loop0,(sign,))
thread.start_new_thread(loop1,(sign,))
whilenotall(sign):pass
print'allDONEat:',ctime()

if__name__=='__main__':
main()

5. python join阻塞主線程，多線程還有什麼意義

問題一：
在start前面還是後面append到列表是完全等價的。
因為你的程序(前面省略)，等價於：

# 開啟新線程
thread1.start()
thread2.start()

# 等待所有線程完成
thread1.join()
thread2.join()

print "Exiting Main Thread"

列表不是必須的。
問題二：
使用join是為了阻塞當前線程(即主線程)，直到兩個子線程結束。

6. python threading 一定要 join 嗎

Join的作用是眾所周知的，阻塞進程直到線程執行完畢。通用的做法是我們啟動一批線程，最後join這些線程結束，例如：

foriinrange(10):
t=ThreadTest(i)
thread_arr.append(t)

foriinrange(10):
thread_arr[i].start()

foriinrange(10):
thread_arr[i].join()


此處join的原理就是依次檢驗線程池中的線程是否結束，沒有結束就阻塞直到線程結束，如果結束則跳轉執行下一個線程的join函數。


而py的join函數還有一個特殊的功能就是可以設置超時，如下：

Thread.join([timeout])

Wait until the thread terminates. This blocks the calling thread until the thread whosejoin()method is called terminates – either normally or through an unhandled exception – or until the optional timeout occurs.


也就是通過傳給join一個參數來設置超時，也就是超過指定時間join就不在阻塞進程。而在實際應用測試的時候發現並不是所有的線程在超時時間內都結束的，而是順序執行檢驗是否在time_out時間內超時，例如，超時時間設置成2s，前面一個線程在沒有完成的情況下，後面線程執行join會從上一個線程結束時間起再設置2s的超時。

7. python 線程join 什麼意思

join的作用是保證當前線程執行完成後，再執行其它線程。join可以有timeout參數，表示阻塞其它線程timeout秒後，不再阻塞。詳見官方文檔。

8. python多線程的join起什麼作用

塞到主線程中

9. python中join如果加在列表下面，是對列表的阻塞還是列表裡面子線程的阻塞

t.join會等待這個t退出後才繼續運行，因為t.join是運行在主線程中，因此會阻塞主線程，即阻塞整個for循環。只有t.join的線程退出後才會繼續執行下一個for循環。在主線程阻塞期間，子線程不會被阻塞，依然會繼續運行。