摘要：的類行為是的類行為的子集，目前尚不支持優(yōu)先級線程組，線程無法銷毀停止暫?；謴?fù)或中斷。表示繼承創(chuàng)建該線程的當(dāng)前線程的屬性。重入鎖，同步原語的一種，可由同一線程多次獲取已持有的鎖。

threading在低級的_thread模塊上構(gòu)建了更高級的線程接口。

threading模塊基于Java線程模型設(shè)計。不過Java中鎖和條件變量是每個對象的基本行為，在python中卻是多帶帶的對象。python的Thread類行為是Java的Thread類行為的子集，目前尚不支持優(yōu)先級、線程組，線程無法銷毀、停止、暫停、恢復(fù)或中斷。Java中Thread類的靜態(tài)方法在Python中映射為模塊級的函數(shù)。

threading.active_count()
返回當(dāng)前活動的Thread對象的數(shù)量，與enumerate()函數(shù)返回的列表元素個數(shù)相同

threading.current_thread()
返回當(dāng)前Thread對象，對應(yīng)調(diào)用者的控制線程(thread of control)。如果調(diào)用者的控制線程不是通過threading模塊創(chuàng)建，返回一個功能受限的啞線程對象(dummy thread object)

threading.get_ident()
返回一個非零整數(shù)，代表當(dāng)前線程的"線程標(biāo)識符"。這個值意在作為魔術(shù)cookie使用，例如作為索引從特定于線程的字典對象獲取數(shù)據(jù)。當(dāng)一個線程退出，新的線程創(chuàng)建，線程標(biāo)識符可能被回收使用

threading.enumerate()
返回當(dāng)前活動Thread對象的列表。該列表包含守護線程、current_thread()函數(shù)創(chuàng)建的啞線程，以及主線程，不包含已終止的線程和未啟動的線程。

threading.main_thread()
返回主線程對象。通常來說，主線程就是啟動python解釋器的線程。

threading.settrace(func)
為啟動自threading模塊的所有線程設(shè)置一個trace函數(shù)。在每個線程的run()方法調(diào)用前，傳遞func參數(shù)給sys.settrace()

threading.setprofile(func)
為啟動自threading模塊的所有線程設(shè)置一個profile函數(shù)。在每個線程的run()方法調(diào)用前，傳遞func參數(shù)給sys.setprofile()

threading.stack_size([size])
返回創(chuàng)建新線程使用的線程堆棧大小。

可選參數(shù)size指定后續(xù)創(chuàng)建的線程的堆棧大小，必須是0(表示使用平臺或配置的默認(rèn)值)或大于等于32768(32KiB)的正整數(shù)。如果未指定，默認(rèn)size為0.

如果不支持改動線程堆棧大小，拋出RuntimeError異常。如果size不合法，拋出ValueError異常，堆棧大小保持不變。

32KiB是目前能保證解釋器堆?？臻g充足的最小值。某些平臺可能對堆棧大小做了特殊的限制，比如要求最小堆棧大小在32KiB以上，或要求以系統(tǒng)內(nèi)存頁大小的倍數(shù)分配。

Windows系統(tǒng)及使用POSIX線程的系統(tǒng)可用

threading.TIMEOUT_MAX
阻塞函數(shù)(Lock.acquire(), RLock.acquire(), Condition.wait()等)的timeout參數(shù)可接受的最大值。超出該值將拋出OverflowError異常。

Thread-local數(shù)據(jù)的值是特定于線程的。管理Thread-local數(shù)據(jù)，只需要創(chuàng)建local或其子類的實例并在該實例上存儲屬性：

mydata = threading.local()
mydata.x = 1

不同的線程，實例的值也會不同。

表示thread-local數(shù)據(jù)的類。

Thread類代表在多帶帶的控制線程中運行的活動，有兩種方式指定：傳遞可調(diào)用對象到構(gòu)造器的target參數(shù)，或重寫子類的run()方法。除了__int__()方法和run()方法，Thread子類不應(yīng)該重寫除此之外的其他方法。

創(chuàng)建的線程對象，必須使用start()方法啟動，start()在一個多帶帶的控制線程調(diào)用run()方法。這時該線程被認(rèn)為是"活動的"。當(dāng)run()方法結(jié)束(正常執(zhí)行完成或拋出了未處理的異常)時，線程對象不再是"活動的"。is_alive()方法可用于檢查線程是否處于活動狀態(tài)。

調(diào)用線程對象的join()方法將導(dǎo)致線程阻塞，直到調(diào)用join()方法的線程執(zhí)行結(jié)束。

線程擁有名字，可以傳遞給構(gòu)造器。通過name屬性讀取或修改。

主線程：對應(yīng)python程序的初始控制線程。主線程不是守護線程。

守護線程：當(dāng)沒有非守護線程處于活動狀態(tài)時，整個python程序?qū)⑼顺觥Ｍㄟ^daemon屬性或構(gòu)造器參數(shù)，可以標(biāo)記一個線程為守護線程。daemon屬性的初始值繼承自創(chuàng)建該線程的線程

啞線程：對應(yīng)"外部線程"alien thread，即在threading模塊之外(比如C代碼)啟動的控制線程。啞線程具有有限的功能，總是認(rèn)為是活動的和守護的，不能調(diào)用join()方法。它們永遠(yuǎn)不會被刪除，因為不能檢測外部線程的結(jié)束情況。

Note：守護線程將在程序關(guān)閉時直接停止。相關(guān)資源(比如打開的文件、數(shù)據(jù)庫事務(wù)等)可能不會被妥善地釋放。如果想要線程優(yōu)雅地停止，將線程設(shè)置為非守護線程，并使用合適的信號機制比如Event

group：None。作為將來實現(xiàn)ThreadGroup類后的保留參數(shù)。

target：可調(diào)用對象，將被run()方法調(diào)用

name：線程名稱。默認(rèn)構(gòu)建Thread-N形式的唯一名稱。

args：target調(diào)用需要接收的位置參數(shù)，元組形式

kwargs：target調(diào)用需要接收的關(guān)鍵字參數(shù)，字典形式

daemon：傳遞一個布爾值，標(biāo)記該線程是否為守護線程。None表示繼承創(chuàng)建該線程的當(dāng)前線程的daemon屬性。

如果子類繼承Thread并重寫構(gòu)造器，必須確保在執(zhí)行線程的其他操作前在構(gòu)造器中調(diào)用Thread.__init__()

start()
開啟線程。每個線程最多只能調(diào)用一次，否則拋出RuntimeError異常。它將在一個多帶帶的控制線程調(diào)用線程對象的run()方法。

run()
定義線程功能的方法，通常在子類中重寫。標(biāo)準(zhǔn)的run()方法調(diào)用傳入構(gòu)造器的可調(diào)用對象target(存在的話)，并使用args和kwargs分別作為target的位置參數(shù)和關(guān)鍵字參數(shù)。

# 創(chuàng)建Thread的實例，傳給它一個函數(shù)

from threading import Thread
from time import sleep, ctime

sleep_time = [4, 2]


def task(task_tag, sleep_tag):
    print("task", task_tag, "started at:", ctime())
    sleep(sleep_tag)
    print("task", task_tag, "done at:", ctime())


def main():
    print("Main thread started at:", ctime())
    threads = []
    nloops = range(len(sleep_time))  # [0, 1]

    for i in nloops:
        t = Thread(target=task, args=(i, sleep_time[i]))
        threads.append(t)

    for i in nloops:
        threads[i].start()  # 啟動線程

    for i in nloops:
        threads[i].join()  # 主線程阻塞，直至調(diào)用join()方法的線程終止

    print("Main thread done at:", ctime())


if __name__ == "__main__":
    main()

# 派生Thread的子類，并創(chuàng)建子類的實例

from threading import Thread
from time import sleep, ctime

sleep_time = [4, 2]


class MyThread(Thread):
    # 重寫run()方法
    def run(self):
        print(self.name, "started at:", ctime())
        self._target(self._args)
        print(self.name, "done at:", ctime())


def task(sleep_tag):
    sleep(sleep_tag)


def main():
    print("Main thread started at:", ctime())
    threads = []
    nloops = range(len(sleep_time))

    for i in nloops:
        t = MyThread(target=task, args=sleep_time[i], name=task.__name__ + str(i))
        threads.append(t)

    for i in nloops:
        threads[i].start()

    for i in nloops:
        threads[i].join()

    print("Main thread done at:", ctime())


if __name__ == "__main__":
    main()

join(timeout=None)
阻塞主線程直到調(diào)用join方法的線程終止(可能是正常執(zhí)行完成，也可能是拋出了未處理的異常)或達(dá)到timeout設(shè)定的時間?？啥啻握{(diào)用。

timeout：阻塞時間(秒)。如果為None，表示一直阻塞直至調(diào)用join方法的線程終止；如果不為None，表示阻塞的時間，達(dá)到該時間后，不管調(diào)用join()方法的線程是否執(zhí)行完成，繼續(xù)執(zhí)行主線程或其他啟動的線程。

如果線程調(diào)用join()方法可能導(dǎo)致死鎖，或在調(diào)用start()之前調(diào)用join()，拋出RuntimeError異常。

name
獲取或設(shè)置線程名稱。多個線程可能名稱相同，初始值由構(gòu)造器設(shè)置。

ident
線程標(biāo)識符，如果為None說明該線程未啟動。當(dāng)一個線程退出，新的線程創(chuàng)建，線程標(biāo)識符可能被回收使用。即使線程退出，該標(biāo)識符仍可用。

is_alive()
判斷線程是否處于活動狀態(tài)。

daemon
布爾標(biāo)志，表示這個線程是否是守護線程。必須在調(diào)用start()之前設(shè)置，否則拋出RuntimeError異常。初始值繼承自創(chuàng)建該線程的線程。主線程不是守護線程，因此在主線程中創(chuàng)建的線程daemon屬性默認(rèn)值為False

CPython實現(xiàn)細(xì)節(jié)：在CPython中，由于GIL的原因，一次只有一個線程能夠執(zhí)行python代碼(即使某些面向性能的庫能克服這個限制???)。想要python程序更好地利用多核機器的計算機資源(計算密集型)，建議使用multiprocessing或concurrent.futures.ProcessPoolExecutor。如果是同時運行多個I/O密集型任務(wù)，threading仍然不失為一個合適的模塊

原語鎖，是同步原語的一種，當(dāng)它處于"locked"狀態(tài)時不屬于特定線程。在python中，這是目前可用的最低級的同步原語，實現(xiàn)自_thread擴展模塊。

原語鎖有兩種狀態(tài)：locked(鎖定)或unlocked(未鎖定)。創(chuàng)建時為未鎖定狀態(tài)。
原語鎖有兩種方法：acquire()和release()。當(dāng)鎖處于未鎖定狀態(tài)時，acquire()改變其為鎖定狀態(tài)。當(dāng)鎖處于鎖定狀態(tài)時，調(diào)用acquire()方法將導(dǎo)致線程阻塞，直到其他線程調(diào)用release()釋放鎖。

acquire(blocking=True, timeout=-1)
獲取鎖。成功返回True，獲取返回False。

blocking：默認(rèn)為True，在獲取到鎖之前阻塞線程；反之即使沒有獲取到鎖也不會阻塞線程。

timeout：指定線程阻塞的最長時間，單位為秒；-1表示無限制等待。當(dāng)blocking為False時，禁止指定timeout參數(shù)

release()
釋放鎖。任何線程都可以調(diào)用，不只是獲取了鎖的線程。

鎖更改為未上鎖狀態(tài)后，對于調(diào)用了acquire()方法而導(dǎo)致阻塞的線程，將由系統(tǒng)決定哪個線程獲取到鎖。

release()方法只能在上鎖狀態(tài)調(diào)用，否則將拋出RuntimeError異常。

重入鎖，同步原語的一種，可由同一線程多次獲取已持有的鎖。除了原語鎖的上鎖/解鎖狀態(tài)，重入鎖還使用了owning thread和recursion level的概念。在上鎖狀態(tài)，可能有多個線程擁有鎖；在解鎖狀態(tài)，沒有線程擁有鎖。

acquire()/release()必須成對出現(xiàn)，可以嵌套，只有最后一個release(即最外層的release)調(diào)用才會最終釋放鎖。

acquire(blocking=True, timeout=-1)
使用默認(rèn)參數(shù)調(diào)用時，如果當(dāng)前線程已經(jīng)擁有鎖，增加1次遞歸深度并立即返回；如果是其他線程擁有鎖，阻塞當(dāng)前線程直到鎖被釋放。一旦鎖釋放(遞歸深度為0，此時鎖不屬于任何線程)，各個線程爭奪鎖，并設(shè)置遞歸深度為1。

release()
釋放鎖且遞歸深度減1。如果調(diào)用后遞歸深度為0，重置鎖為未鎖定狀態(tài)(不屬于任何線程)，由其他線程爭奪鎖。如果調(diào)用后遞歸深度非0，鎖仍為上鎖狀態(tài)，屬于當(dāng)前線程。

只能由已經(jīng)獲取了鎖的線程調(diào)用，否則拋出RuntimeError異常。

condition變量總是與某種鎖相聯(lián)系：傳入或者默認(rèn)創(chuàng)建的鎖對象。傳入鎖對象適用于多個condition變量需要共享同一個鎖的場景。鎖是condition對象的一部分，不需要對鎖多帶帶進(jìn)行追蹤。

condition對象遵循上下文管理協(xié)議：使用with語句在封閉塊內(nèi)獲取關(guān)聯(lián)的鎖對象，在condition對象上調(diào)用acquire和release實際上調(diào)用的是關(guān)聯(lián)鎖的對應(yīng)方法。

條件變量允許一個或多個線程等待，直到接收到另一個線程的通知。

lock參數(shù)必須是Lock或RLock對象，作為底層的鎖使用。默認(rèn)使用RLock

acquire(*args)
調(diào)用底層lock對象的acquire()方法獲取鎖

release()
調(diào)用底層lock對象的release()方法釋放鎖

wait(timeout=None)
釋放鎖并阻塞當(dāng)前線程直到被另外一個線程調(diào)用notify()或notify_all()喚醒，或者達(dá)到設(shè)置的timeout時間，任意一種情況都將重新獲取鎖并返回。
只能由已獲取到鎖的線程調(diào)用，否則拋出RuntimeError異常。

3.2版本前該方法始終返回None，3.2版本開始除非超時會返回False，其他情況都返回True

wait_for(predicate, timeout=None)
阻塞當(dāng)前線程直到可調(diào)用對象predicate返回值為True或bool()判斷為True。

wait_for方法將不斷調(diào)用wait()方法直到超時或滿足predicate返回值為True或bool()判斷為True。

返回值為最后一次執(zhí)行predicate的返回值，如果超時返回False。

只能由已獲取到鎖的線程調(diào)用，否則拋出RuntimeError異常。

notify(n=1)
喚醒wait()或wait_for()狀態(tài)下的某個線程。只能由已獲取到鎖的線程調(diào)用，否則拋出RuntimeError異常。

notify_all()
喚醒wait()或wait_for()狀態(tài)下的所有線程。只能由已獲取到鎖的線程調(diào)用，否則拋出RuntimeError異常。

notify()和notify_all()并不釋放鎖。意思是調(diào)用wait()方法的線程不會立即返回，需要等到調(diào)用notify()和notify_all()的線程釋放鎖之后才返回。

# 生產(chǎn)者-消費者模式中Condition的用法

# 消費者：
with cv:
    while not an_item_is_available():
        cv.wait()
    get_an_available_item()

# 生產(chǎn)者：
with cv:
    make_an_item_available()
    cv.notify()

# 消費者(使用wait_for改進(jìn))：
with cv:
    cv.wait_for(an_item_is_available)
    get_an_available_item()

信號量對象管理一個內(nèi)部計數(shù)器，隨著調(diào)用acquire()減1，release()調(diào)用加1，但一定不會小于0。當(dāng)調(diào)用acquire()時如果計數(shù)器等于0將會阻塞線程直到某個線程調(diào)用release()方法。支持上下文管理器協(xié)議

指定初始計數(shù)器的信號量，每調(diào)用一次release()加1，每調(diào)用一次acquire()減1。

acquire(blocking=True, timeout=None)
獲取信號量。

使用默認(rèn)參數(shù)調(diào)用時：

1. 如果計數(shù)器大于0，減1并立即返回True
2. 如果計數(shù)器等于0，阻塞直到某個線程調(diào)用release()喚醒，喚醒后計數(shù)器減1并返回True

release()
釋放信號量。

邊界信號量，計數(shù)器值不能超過設(shè)置的最大邊界。常用于限制資源占用的場景比如數(shù)據(jù)庫連接。

事件是最簡單的線程間通信機制。事件對象管理一個內(nèi)部標(biāo)志，調(diào)用set()時該標(biāo)志為True，調(diào)用clear()時該標(biāo)志為False，調(diào)用wait()時線程阻塞直到標(biāo)志為True

is_set()
如果事件標(biāo)志為True，返回True

set()
設(shè)置事件標(biāo)志為True。將喚醒所有調(diào)用了wait()而阻塞的線程。

clear()
重置事件標(biāo)志為False。將阻塞所有調(diào)用了wait()的線程。

wait(timeout=None)
阻塞線程直到事件標(biāo)志為True或超時。

Timer繼承自Thread，表示經(jīng)過一定時間后要運行的任務(wù)。

創(chuàng)建定時器，在interval時間后運行function任務(wù)。

cancel()
終止定時器并結(jié)束任務(wù)(僅對待執(zhí)行狀態(tài)中的任務(wù)有效)。

Python 多線程： threading.local類