理解 Python 中的線程

　　我們將會看到一些在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()

　　这次我们看到了正确的结果。证明了一个线程不可以修改其他线程内部的变量（非全局变量）。

　　原文出处： Akshar Raaj

以上是理解 Python 中的線程的詳細內容。更多資訊請關注PHP中文網其他相關文章！