python中的線程詳解

轉 : https://www.jianshu.com/p/4a13a05e4f1f

我們将會看到一些在Python中使用線程的執行個體和如何避免線程之間的競争。

你應當将下邊的例子運作多次，以便可以注意到線程是不可預測的和線程每次運作出的不同結果。

聲明：從這裡開始忘掉你聽到過的關于GIL的東西，因為GIL不會影響到我想要展示的東西。

示例1:

我們将要請求五個不同的url：

單線程

import time
import urllib2

def get_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()
    for url in urls:
        print url
        resp = urllib2.urlopen(url)
        print resp.getcode()
    print "Elapsed time: %s" % (time.time()-start)

get_responses()
                

輸出是：

http://www.google.com 200
http://www.amazon.com 200
http://www.ebay.com 200
http://www.alibaba.com 200
http://www.reddit.com 200
Elapsed time: 3.0814409256
                

解釋：

• url順序的被請求
• 除非cpu從一個url獲得了回應，否則不會去請求下一個url
• 網絡請求會花費較長的時間，是以cpu在等待網絡請求的傳回時間内一直處于閑置狀态。

多線程

import urllib2
import time
from threading import Thread

class GetUrlThread(Thread):
    def __init__(self, url):
        self.url = url 
        super(GetUrlThread, self).__init__()

    def run(self):
        resp = urllib2.urlopen(self.url)
        print self.url, resp.getcode()

def get_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 = []
    for url in urls:
        t = GetUrlThread(url)
        threads.append(t)
        t.start()
    for t in threads:
        t.join()
    print "Elapsed time: %s" % (time.time()-start)

get_responses()
                

輸出:

http://www.reddit.com 200
http://www.google.com 200
http://www.amazon.com 200
http://www.alibaba.com 200
http://www.ebay.com 200
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 

class IncrementThread(Thread):
    def run(self):
        #we want to read a global variable
        #and then increment it
        global some_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)

def use_increment_thread():
    threads = []
    for i in range(50):
        t = IncrementThread()
        threads.append(t)
        t.start()
    for t in threads:
        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 


class IncrementThread(Thread):
    def run(self):
        #we want to read a global variable
        #and then increment it
        global some_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()

def use_increment_thread():
    threads = []
    for i in range(50):
        t = IncrementThread()
        threads.append(t)
        t.start()
    for t in threads:
        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

class CreateListThread(Thread):
    def run(self):
        self.entries = []
        for i in range(10):
            time.sleep(1)
            self.entries.append(i)
        print self.entries

def use_create_list_thread():
    for i in range(3):
        t = CreateListThread()
        t.start()

use_create_list_thread()
                

運作幾次後發現并沒有列印出争取的結果。當一個線程正在列印的時候，cpu切換到了另一個線程，是以産生了不正确的結果。我們需要確定

print self.entries

是個邏輯上的原子操作，以防列印時被其他線程打斷。

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

from threading import Thread, Lock
import time

lock = Lock()

class CreateListThread(Thread):
    def run(self):
        self.entries = []
        for i in range(10):
            time.sleep(1)
            self.entries.append(i)
        lock.acquire()
        print self.entries
        lock.release()

def use_create_list_thread():
    for i in range(3):
        t = CreateListThread()
        t.start()

use_create_list_thread()
                

這次我們看到了正确的結果。證明了一個線程不可以修改其他線程内部的變量（非全局變量）