理解 Python 中的線程

jopen 10年前發布 | 10K 次閱讀 Python Python開發

我們將會看到一些在Python中使用線程的實例和如何避免線程之間的競爭。你應當將下邊的例子運行多次,以便可以注意到線程是不可預測的和線程每次運行出的不同結果。聲明:從這里開始忘掉你聽到過的關于GIL的東西,因為GIL不會影響到我想要展示的東西。

示例1

我們將要請求五個不同的url:

單線程
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
importtime
importurllib2
 
defget_responses():
    urls=[
        'http://www.google.com',
        'http://www.amazon.com',
        'http://www.ebay.com',
        'http://www.alibaba.com',
        'http://www.reddit.com'
    ]
    start=time.time()
    forurlinurls:
        printurl
        resp=urllib2.urlopen(url)
        printresp.getcode()
    print"Elapsed time: %s"%(time.time()-start)
 
get_responses()

輸出是:

1
2
3
4
5
6
http://www.google.com200
http://www.amazon.com200
http://www.ebay.com200
http://www.alibaba.com200
http://www.reddit.com200
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
importurllib2
importtime
fromthreadingimportThread
 
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.google.com',
        'http://www.amazon.com',
        'http://www.ebay.com',
        'http://www.alibaba.com',
        'http://www.reddit.com'
    ]
    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()

輸出:

1
2
3
4
5
6
http://www.reddit.com200
http://www.google.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 。
  • 有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
fromthreadingimportLock, 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()可以使一個線程掛起,強制線程切換發生。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
fromthreadingimportThread
importtime
 
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
fromthreadingimportThread, Lock
importtime
 
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()

這次我們看到了正確的結果。證明了一個線程不可以修改其他線程內部的變量(非全局變量)。

 本文由用戶 jopen 自行上傳分享,僅供網友學習交流。所有權歸原作者,若您的權利被侵害,請聯系管理員。
 轉載本站原創文章,請注明出處,并保留原始鏈接、圖片水印。
 本站是一個以用戶分享為主的開源技術平臺,歡迎各類分享!