Python多執行緒學習 setDae

（2）setDaemon方法：

# -*- coding: utf-8 -*- import threading import time class myThread(threading.Thread):     def __init__(self, threadname):         threading.Thread.__init__(self, name=threadname)     def run(self):         time.sleep(5)         print '%s is running·······done'%self.getName() t=myThread('son thread') #t.setDaemon(True) t.start() if t.isDaemon():     print "the father thread and the son thread are done" else:     print "the father thread is waiting the son thread····"

這段程式碼的運行流程是：主執行緒列印完最後一句話後，等待son thread  運行完，然後程式才結束，所以輸出結果為：

Python程式碼

  1. the father thread is waitting the son thread····  
  2. son thread is running·······done  
<span style="font-size:24px;">the father thread is waitting the son thread····  son thread is running·······done</span>

如果啟用t.setDaemon(True) ，這段程式碼的運行流程是：當主執行緒列印完最後一句話後，不管 son thread 是否運行完，程式立即結束，所以輸出結果為：

Python程式碼

  1. the father thread and the son thread are done 

執行緒的合併 python的Thread類中還提供了join()方法，使得一個執行緒可以等待另一個執行緒執行結束後再繼續運行。這個方法還可以設定一個timeout參數，避免無休止的等待。因為兩個執行緒順序完成，看起來象一個執行緒，所以稱為執行緒的合併。一個例子：

  1. import threading
  2. import random
  3. import time
  5. class MyThread(threading.Thread):
  7.     def run(self):
  8. wait_time=random.randrange(1,10)
  9.         print "%s will wait %d seconds" % (self.name, wait_time)
  10.         time.sleep(wait_time)
  11.         print "%s finished!" % self.name
  13. if __name__=="__main__":
  14.     threads = []
  15. for i in range(5):
  16.         t = MyThread()
  17.         t.start()
  18.         threads.append(t)
  19.     print 'main thread is waitting for exit…'        
  20. for t in threads:
  21.         t.join(1)
  23.     print 'main thread finished!'

執行結果：

  1. Thread-1 will wait 3 secondsThread-2 will wait 4 seconds
  2. Thread-3 will wait 1 seconds
  3. Thread-4 will wait 5 seconds
  4. Thread-5 will wait 3 seconds
  5. main thread is waitting for exit…
  6. Thread-3 finished!
  7. Thread-1 finished!
  8. Thread-5 finished!
  9. main thread finished!
  10. Thread-2 finished!
  11. Thread-4 finished!

對於sleep時間過長的執行緒（這裡是2和4），將不被等待。 注意： Thread.join([timeout])Wait until the thread terminates. This blocks the calling thread until the thread whose join() method is called terminates – either normally or through an unhandled exception – or until the optional timeout occurs.也就是通過傳給join一個參數來設置超時，也就是超過指定時間join就不在阻塞進程。而在實際應用測試的時候發現並不是所有的執行緒在超時時間內都結束的，而是順序執行檢驗是否在time_out時間內超時，例如，超時時間設置成2s，前面一個執行緒在沒有完成的情況下，後面執行緒執行join會從上一個執行緒結束時間起再設置2s的超時。

根據這段解釋，來分析一下程式的運行：

main thread先對Thread-1執行join操作，有1秒的timeout。

當過去1秒之後，main thread發現Thread-1還沒有結束（Thread-1需要運行3秒才結束，現在還剩2秒），因此發生timeout，轉而繼續對Thread-2執行join操作。此次此刻，Thread-3恰巧結束，輸入調試語句。

又過去1秒（總共運行了2秒），main thread發現Thread-2也沒有結束（Thread-2需要運行4秒才結束，現在還剩2秒），因此同樣發生timeout，繼續對Thread-3執行join操作。由於Thread-3之前已結束，轉而對Thread-4執行join操作。

再過去1秒（總共運行了3秒），main thread發現Thread-4沒有結束（Thread-4需要5秒運行，現在還剩2秒），因此發生timeout，繼續對Thread-5執行join操作。此時，Thread-1和Thread-5恰巧結束，輸出調試語句。

main thread已經完成了對所有需要join的執行緒的觀察和超時，因此main thread執行緒可以結束了。

時間又經過1秒，Thread-2結束。

再經過1秒，Thread-4結束。

後台執行緒 默認情況下，主執行緒在退出時會等待所有子執行緒的結束。如果希望主執行緒不等待子執行緒，而是在退出時自動結束所有的子執行緒，就需要設置子執行緒為後台執行緒(daemon)。方法是通過調用執行緒類的setDaemon()方法。如下：

  1. import threading
  2. import random
  3. import time
  5. class MyThread(threading.Thread):
  7.     def run(self):
  8.         wait_time=random.randrange(1,10)
  9.         print "%s will wait %d seconds" % (self.name, wait_time)
  10.         time.sleep(wait_time)
  11.         print "%s finished!" % self.name
  13. if __name__=="__main__":
  14.     print 'main thread is waitting for exit…'        
  16.     for i in range(5):
  17.         t = MyThread()
  18.         t.setDaemon(True)
  19.         t.start()
  21.     print 'main thread finished!'

複製程式碼

執行結果：

main thread is waitting for exit… Thread-1 will wait 3 seconds Thread-2 will wait 3 seconds Thread-3 will wait 4 seconds Thread-4 will wait 7 seconds Thread-5 will wait 7 seconds main thread finished! main thread is waitting for exit… Thread-1 will wait 3 seconds Thread-2 will wait 3 seconds Thread-3 will wait 4 seconds Thread-4 will wait 7 seconds Thread-5 will wait 7 seconds main thread finished!

可以看出，主執行緒沒有等待子執行緒的執行，而直接退出。 小結 join()方法使得執行緒可以等待另一個執行緒的運行，而setDaemon()方法使得執行緒在結束時不等待子執行緒。join和setDaemon都可以改變執行緒之間的運行順序。 

<span style="font-size:24px;">the father thread and the son thread are done</span>

VirMach 便宜 VPS

QNews

QNews