摘要：介紹今天花了近乎一天的時間研究關于多線程的問題，查看了大量源碼自己也實踐了一個生產消費者模型，所以把一天的收獲總結一下。提供了兩個模塊和來支持的多線程操作。使用來阻塞線程。

今天花了近乎一天的時間研究python關于多線程的問題，查看了大量源碼 自己也實踐了一個生產消費者模型，所以把一天的收獲總結一下。

由于GIL(Global Interpreter Lock)鎖的關系,純的python代碼處理一般邏輯的確無法活動性能上的極大提升，但是在處理需要等待外部資源返回或多用戶的應用程序中，多線程仍然可以作為一個比較好的工具來進行使用。

python提供了兩個模塊thread和threading 來支持python的多線程操作。通俗的講一般現(xiàn)在我們只使用threading模塊來編程了，thread模塊定義了很多原始行為，更接近底層，而threading模塊抽象了thread模塊可用性更好，同時提供更多特性。

現(xiàn)在創(chuàng)建線程的通用方法一般是創(chuàng)建一個類并且繼承threading.Thread，然后重寫其中的__init__和run()方法。 更多詳情可以參考threading模塊代碼內注釋以及代碼。下面直接看個例子。

import time
import threading


class Test(threading.Thread):
    def __init__(self, name, delay):
        super(Test, self).__init__()
        self.name = name
        self.delay = delay

    def run(self):
        print "%s delay for %s seconds" % (self.name, self.delay)
        time.sleep(self.delay)
        c = 0
        while True:
            print "This is thread %s on line %s" % (self.name, c)
            c += 1
            if c == 3:
                print "End of thread %s" % self.name
                break


t1 = Test("Thread1", 5)
t2 = Test("Thread2", 5)

t1.start()
print "Wait t1 to end"
t1.join()
t2.start()
t2.join()
print "End of main"

注意一下這一句 ：

super(Test, self).__init__()

這是按照模塊要求，必須初始化父類的__init__函數(shù) 所以使用了super()

其他并沒有多少值得注意的地方，

創(chuàng)建線程方便的實例化自己寫的繼承threading.Thread的類 然后傳入對應的參數(shù)。

最后使用xxx.start()來運行線程。 使用xxx.join()來阻塞線程。

特別注意的是。繼承自Threading類的子類還有一個daemon參數(shù)，如果這個參數(shù)適用setDaemon()方法置為True之后，主線程將不會等待子線程都結束之后才結束，而是自己運行完之后就結束，這種方式相當粗暴。 如果將daemon參數(shù)設置為False的話，主線成將會等待所有子線程結束之后再結束。daemon屬性可以通過使用isDaemon()方法獲取一個boolean值。

更進一步的，我必須介紹一下線程之間的同步和互斥問題。下面引用《計算機操作系統(tǒng)》中的介紹。

當線程并發(fā)執(zhí)行時，由于資源共享和線程協(xié)作，使用線程之間會存在以下兩種制約關系。
（1）間接相互制約。一個系統(tǒng)中的多個線程必然要共享某種系統(tǒng)資源，如共享CPU，共享I/O設備，所謂間接相互制約即源于這種資源共享，打印機就是最好的例子，線程A在使用打印機時，其它線程都要等待。
（2）直接相互制約。這種制約主要是因為線程之間的合作，如有線程A將計算結果提供給線程B作進一步處理，那么線程B在線程A將數(shù)據(jù)送達之前都將處于阻塞狀態(tài)。
間接相互制約可以稱為互斥，直接相互制約可以稱為同步，對于互斥可以這樣理解，線程A和線程B互斥訪問某個資源則它們之間就會產個順序問題——要么線程A等待線程B操作完畢，要么線程B等待線程操作完畢，這其實就是線程的同步了。因此同步包括互斥，互斥其實是一種特殊的同步。
在一段時間內只允許一個線程訪問的資源就稱為臨界資源或獨占資源，計算機中大多數(shù)物理設備，進程中的共享變量等待都是臨界資源，它們要求被互斥的訪問。每個進程中訪問臨界資源的代碼稱為臨界區(qū)。

這里為了介紹這種稍微復雜的概念。 再列出一個生產消費者的例子 使用到了Queue隊列。

# coding:utf-8
import Queue
import time
import random
import threading


# write_lock = threading.Lock()                                                 # 創(chuàng)建primitive鎖對象用于控制輸出


class Producer(threading.Thread):
    # q傳遞一個隊列參數(shù), con傳遞了一個鏈接, name傳遞了一個名字
    def __init__(self, q, name):
        super(Producer, self).__init__()
        self.q = q
        # self.con = con
        self.name = name
        print "Producer " + self.name + "Started"

    def run(self):
        while True:
            # 鎖對象常用的acquire獲得鎖方法和release釋放鎖方法
            # 這里使用的是Thread的Condition對象
            # self.con.acquire()
            if self.q.full():
                print "Queue is full, producer wait!"

                # 手動掛起,并且只能在獲得Lock的情況下才可以使用 否則會觸發(fā)RuntimeError
                # 調用wait()會釋放Lock 直到該線程被notify(),notifyall()或超時該線程又重新獲得Lock
                # self.con.wait()
            else:
                value = random.randint(0, 10)
                print self.name + " put " + str(value) + "into queue"
                self.q.put((self.name+":"+str(value)))                    # 放置到隊列中

                # 通知消費者,notify通知其他線程,被掛起的線程接到通知后會開始運行
                # 默認通知一個正在等待該condition的線程,最多喚醒n個線程 必須在獲得Lock的情況下使用否則會報錯.
                # self.con.notify()
                # self.con.release()                                            # 釋放鎖對象


class Consumer(threading.Thread):
    def __init__(self, q, name):
        super(Consumer, self).__init__()
        self.q = q
        # self.con = con
        self.name = name
        print "Consumer " + self.name + "started
"

    def run(self):
        while True:
            # Condition常用的acquire獲得鎖方法和release釋放鎖方法
            # self.con.acquire()
            if self.q.empty():
                print "queue is empty, consumer wait!"
                # self.con.wait()
            else:
                value = self.q.get()                                            # 從隊列中取消息
                print self.name + " get " + value + "from queue"

                # 發(fā)送消息通知生產者
                # self.con.notify()
                # self.con.release()                                              # 釋放鎖對象
                print "queue still have " + str(q.qsize()) + "task
"


if __name__ == "__main__":
    q = Queue.Queue(10)

    # 使用Condition對象可以在某些事件觸發(fā)或達到特定的條件后才處理數(shù)據(jù).
    # con = threading.Condition()

    # 兩個生產者
    p1 = Producer(q, "P1")
    p2 = Producer(q, "P2")
    c1 = Consumer(q, "C1")
    p2.start()
    p1.start()
    c1.start()

若有問題歡迎指出

python threading模塊文檔翻譯： http://my.oschina.net/lionets/blog/194577?fromerr=pbWOeveo

多線程7經(jīng)典線程與互斥總結：http://blog.csdn.net/dazhong159/article/details/7927034

《編寫高質量代碼改善python程序的91個建議》第48和49建議。