深入理解 Python 中的多線程 新手必看

範例1
我們將要要求五個不同的url：
單線程

import time 
import urllib2    
defget_responses():   
urls=[     
‘http://www.baidu.com',     
‘http://www.amazon.com',     
‘http://www.ebay.com',     
‘http://www.alibaba.com',     
‘http://www.jb51.net'  
 ]   
start=time.time()  
forurlinurls:    
printurl    
resp=urllib2.urlopen(url)     
printresp.getcode()  
print”Elapsed time: %s”%(time.time()-start)    
get_responses()

輸出是：
http://www.baidu.com200
http://www.amazon.com200
http://www.ebay .com200
http://www.alibaba.com200
http://www.jb51.net200
Elapsed time:3.0814409256

解釋：
url順序的被請求
除非cpu從一個url獲得了回應，否則不會去請求下一個url
網絡請求會花費較長的時間，所以cpu在等待網絡請求的返回時間內部一直處於閒置狀態。
多執行緒

import urllib2 
import time 
from threading import Thread   
classGetUrlThread(Thread):   
def__init__(self, url):     
self.url=url     
super(GetUrlThread,self).__init__()      
defrun(self):     
resp=urllib2.urlopen(self.url)     
printself.url, resp.getcode()    
defget_responses():   urls=[     
‘http://www.baidu.com',     
‘http://www.amazon.com',     
‘http://www.ebay.com',     
‘http://www.alibaba.com',     
‘http://www.jb51.net'   
]   
start=time.time()   
threads=[]   
forurlinurls:     
t=GetUrlThread(url)     
threads.append(t)     
t.start()   
fortinthreads:     
t.join()   
print”Elapsed time: %s”%(time.time()-start)    
get_responses()

輸出：
http://www.jb51.net200
http://www.baidu.com200
http://www.amazon.com200
http://www.alibaba.com2000 ://www.ebay.com200
Elapsed time:0.689890861511

解釋：

意識到了程式在執行時間上的提升

我們寫了一個多執行緒程式來減少cpu的等待時間，當我們在等待一個執行緒內的網路請求返回時，這時cpu可以切換到其他執行緒去進行其他執行緒內的網路請求。
我們期望一個執行緒處理一個url，所以實例化執行緒類別的時候我們傳了一個url。
執行緒運行意味著執行類別裡的run()方法。
無論如何我們想每個執行緒必須執行run()。
為每個url建立一個執行緒並且呼叫start()方法，這告訴了cpu可以執行緒中的run()方法了。
我們希望所有的執行緒執行完畢的時候再計算花費的時間，所以呼叫了join()方法。
join()可以通知主執行緒等待這個執行緒結束後，才可以執行下一條指令。
每個執行緒我們都呼叫了join()方法，所以我們是在所有執行緒執行完畢後計算的運行時間。

關於執行緒：

cpu可能不會在呼叫start()後馬上執行run()方法。

你不能確定run()在不同執行緒建間的執行順序。
對於單獨的一個線程，可以保證run()方法裡的語句是依照順序執行的。
這就是因為執行緒內的url會先被要求，然後再印出回傳的結果。

實例2

我們將會用一個程式示範多執行緒間的資源競爭，並修正這個問題。

from threading import Thread    
#define a global variable some_var=0   
classIncrementThread(Thread):   
defrun(self):     
#we want to read a global variable     
#and then increment it     
globalsome_var     
read_value=some_var     
print”some_var in %s is %d”%(self.name, read_value)     
some_var=read_value+1    
print”some_var in %s after increment is %d”%(self.name, some_var)    
defuse_increment_thread():   
threads=[]   
foriinrange(50):     
t=IncrementThread()     
threads.append(t)     
t.start()   
fortinthreads:     
t.join()   
print”After 50 modifications, some_var should have become 50″   
print”After 50 modifications, some_var is %d”%(some_var,)    
use_increment_thread()

多次運行這個程序，你會看到多種不同的結果。

解釋：
有一個全域變量，所有的執行緒都想修改它。
所有的執行緒應該在這個全域變數上加 1 。
有50個線程，最後這個數值應該變成50，但是它卻沒有。
為什麼沒有達到50？
在some_var是15的時候，線程t1讀取了some_var，這個時刻cpu將控制權給了另一個線程t2。
t2線程讀到的some_var也是15
t1和t2都把some_var加到16
當時我們期望的是t1 t2兩個線程使some_var + 2變成17
在這裡就有了資源競爭。
相同的情況也可能發生在其它的線程間，所以出現了最後的結果小於50的情況。
解決資源競爭

from threading 
import Lock, Thread 
lock=Lock() 
some_var=0   
classIncrementThread(Thread):   
defrun(self):     
#we want to read a global variable     
#and then increment it     
globalsome_var     
lock.acquire()     
read_value=some_var     
print”some_var in %s is %d”%(self.name, read_value)     
some_var=read_value+1    
print”some_var in %s after increment is %d”%(self.name, some_var)     
lock.release()    
defuse_increment_thread():   
threads=[]   
foriinrange(50):     
t=IncrementThread()     
threads.append(t)     
t.start()   
fortinthreads:     
t.join()   
print”After 50 modifications, some_var should have become 50″   
print”After 50 modifications, some_var is %d”%(some_var,)    
use_increment_thread()

再次運行這個程序，達到了我們預期的結果。

解釋：
Lock 用來防止競爭條件
如果在執行一些操作之前，線程t1獲得了鎖。其他的線程在t1釋放Lock之前，不會執行相同的操作
我們想要確定的是一旦線程t1已經讀取了some_var，直到t1完成了修改some_var，其他的線程才可以讀取some_var
這樣讀取而修改some_var成了邏輯上的原子操作。
實例3
讓我們用一個例子來證明一個執行緒不能影響其他執行緒內的變數（非全域變數）。
time.sleep()可以使一個執行緒掛起，強制執行緒切換發生。

from threading import Thread 
import time    
classCreateListThread(Thread):   
defrun(self):     
self.entries=[]     
foriinrange(10):       
time.sleep(1)       
self.entries.append(i)     
printself.entries    
defuse_create_list_thread():   
foriinrange(3):     
t=CreateListThread()     
t.start()    
use_create_list_thread()

運行幾次後發現並沒有印出爭取的結果。當一個線程正在列印的時候，cpu切換到了另一個線程，所以產生了不正確的結果。我們需要確保print self.entries是個邏輯上的原子操作，以防列印時被其他執行緒打斷。

我們使用了Lock()，來看下邊的範例。

from threading import Thread, Lock 
import time    
lock=Lock()    
classCreateListThread(Thread):   
defrun(self):     
self.entries=[]     
foriinrange(10):       
time.sleep(1)       
self.entries.append(i)     
lock.acquire()     
printself.entries     
lock.release()    
defuse_create_list_thread():   
foriinrange(3):     
t=CreateListThread()     
t.start()    
use_create_list_thread()

這次我們看到了正確的結果。證明了一個執行緒不可以修改其他執行緒內部的變數（非全域變數）。