示例1
我們將要請求五個不同的url：
單線程
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
import timeimport urllib2 defget_responses(): urls=[ ‘http://www.baidu.com', ‘http://www.amazon.com', ‘http://www.ebay.com', ‘http://www.alibaba.com', ] 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.zmynmublwnt.cn200
Elapsed time:3.0814409256
解釋：
url順序的被請求
除非cpu從一個url獲得了回應，否則不會去請求下一個url
網絡請求會花費較長的時間，所以cpu在等待網絡請求的返回時間內一直處于閑置狀態。
多線程
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
|
import urllib2import timefrom 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', ‘https://www.zmynmublwnt.cn' ] 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.zmynmublwnt.cn200
http://www.baidu.com200
http://www.amazon.com200
http://www.alibaba.com200
http://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
我們將會用一個程序演示一下多線程間的資源競爭，并修復這個問題。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
from threading import Thread #define a global variablesome_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的情況。
解決資源競爭
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
from threading import Lock, Threadlock=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()可以使一個線程掛起，強制線程切換發生。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
from threading import Threadimport 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()，來看下邊的例子。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
from threading import Thread, Lockimport 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() |
這次我們看到了正確的結果。證明了一個線程不可以修改其他線程內部的變量（非全局變量）。
