摘要：進(jìn)程可創(chuàng)建多個線程來執(zhí)行同一程序的不同部分。就緒等待線程調(diào)度。運(yùn)行線程正常運(yùn)行阻塞暫停運(yùn)行，解除阻塞后進(jìn)入狀態(tài)重新等待調(diào)度。消亡線程方法執(zhí)行完畢返回或者異常終止。多線程多的情況下，依次執(zhí)行各線程的方法，前頭一個結(jié)束了才能執(zhí)行后面一個。

作者簡介:

姓名:黃志成(小黃)
博客: 博客

操作系統(tǒng)原理相關(guān)的書，基本都會提到一句很經(jīng)典的話： "進(jìn)程是資源分配的最小單位，線程則是CPU調(diào)度的最小單位"。

線程是操作系統(tǒng)能夠進(jìn)行運(yùn)算調(diào)度的最小單位。它被包含在進(jìn)程之中，是進(jìn)程中的實(shí)際運(yùn)作單位。一條線程指的是進(jìn)程中一個單一順序的控制流，一個進(jìn)程中可以并發(fā)多個線程，每條線程并行執(zhí)行不同的任務(wù)

好處 ：

1.易于調(diào)度。

2.提高并發(fā)性。通過線程可方便有效地實(shí)現(xiàn)并發(fā)性。進(jìn)程可創(chuàng)建多個線程來執(zhí)行同一程序的不同部分。

3.開銷少。創(chuàng)建線程比創(chuàng)建進(jìn)程要快，所需開銷很少。

4.利于充分發(fā)揮多處理器的功能。通過創(chuàng)建多線程進(jìn)程，每個線程在一個處理器上運(yùn)行，從而實(shí)現(xiàn)應(yīng)用程序的并發(fā)性，使每個處理器都得到充分運(yùn)行。

在解釋python多線程的時候. 先和大家分享一下 python 的GIL 機(jī)制。

Python代碼的執(zhí)行由Python 虛擬機(jī)(也叫解釋器主循環(huán)，CPython版本)來控制，Python 在設(shè)計(jì)之初就考慮到要在解釋器的主循環(huán)中，同時只有一個線程在執(zhí)行，即在任意時刻，只有一個線程在解釋器中運(yùn)行。對Python 虛擬機(jī)的訪問由全局解釋器鎖（GIL）來控制，正是這個鎖能保證同一時刻只有一個線程在運(yùn)行。

在多線程環(huán)境中，Python 虛擬機(jī)按以下方式執(zhí)行：

設(shè)置GIL

切換到一個線程去運(yùn)行

運(yùn)行：
a. 指定數(shù)量的字節(jié)碼指令，或者
b. 線程主動讓出控制（可以調(diào)用time.sleep(0)）

把線程設(shè)置為睡眠狀態(tài)

解鎖GIL

再次重復(fù)以上所有步驟

首先需要明確的一點(diǎn)是GIL并不是Python的特性，它是在實(shí)現(xiàn)Python解析器(CPython)時所引入的一個概念。Python同樣一段代碼可以通過CPython，PyPy，Psyco等不同的Python執(zhí)行環(huán)境來執(zhí)行。像其中的JPython就沒有GIL。然而因?yàn)镃Python是大部分環(huán)境下默認(rèn)的Python執(zhí)行環(huán)境。所以在很多人的概念里CPython就是Python，也就想當(dāng)然的把GIL歸結(jié)為Python語言的缺陷。所以這里要先明確一點(diǎn)：GIL并不是Python的特性，Python完全可以不依賴于GIL

還有，就是在做I/O操作時，GIL總是會被釋放。對所有面向I/O 的(會調(diào)用內(nèi)建的操作系統(tǒng)C 代碼的)程序來說，GIL 會在這個I/O 調(diào)用之前被釋放，以允許其它的線程在這個線程等待I/O 的時候運(yùn)行。如果是純計(jì)算的程序，沒有 I/O 操作，解釋器會每隔 100 次操作就釋放這把鎖，讓別的線程有機(jī)會執(zhí)行（這個次數(shù)可以通過 sys.setcheckinterval 來調(diào)整）如果某線程并未使用很多I/O 操作，它會在自己的時間片內(nèi)一直占用處理器（和GIL）。也就是說，I/O 密集型的Python 程序比計(jì)算密集型的程序更能充分利用多線程環(huán)境的好處。

各個狀態(tài)說明：

New新建 ：新創(chuàng)建的線程經(jīng)過初始化后，進(jìn)入Runnable狀態(tài)。

Runnable就緒：等待線程調(diào)度。調(diào)度后進(jìn)入運(yùn)行狀態(tài)。

Running運(yùn)行：線程正常運(yùn)行

Blocked阻塞：暫停運(yùn)行，解除阻塞后進(jìn)入Runnable狀態(tài)重新等待調(diào)度。

Dead消亡：線程方法執(zhí)行完畢返回或者異常終止。

可能有3種情況從Running進(jìn)入Blocked：

同步：線程中獲取同步鎖，但是資源已經(jīng)被其他線程鎖定時，進(jìn)入Locked狀態(tài)，直到該資源可獲取（獲取的順序由Lock隊(duì)列控制）

睡眠：線程運(yùn)行sleep()或join()方法后，線程進(jìn)入Sleeping狀態(tài)。區(qū)別在于sleep等待固定的時間，而join是等待子線程執(zhí)行完。sleep()確保先運(yùn)行其他線程中的方法。當(dāng)然join也可以指定一個“超時時間”。從語義上來說，如果兩個線程a,b, 在a中調(diào)用b.join()，相當(dāng)于合并(join)成一個線程。將會使主調(diào)線程(即a)堵塞(暫停運(yùn)行, 不占用CPU資源), 直到被調(diào)用線程運(yùn)行結(jié)束或超時, 參數(shù)timeout是一個數(shù)值類型，表示超時時間，如果未提供該參數(shù)，那么主調(diào)線程將一直堵塞到被調(diào)線程結(jié)束。最常見的情況是在主線程中join所有的子線程。

等待：線程中執(zhí)行wait()方法后，線程進(jìn)入Waiting狀態(tài)，等待其他線程的通知(notify）。wait方法釋放內(nèi)部所占用的瑣，同時線程被掛起，直至接收到通知被喚醒或超時（如果提供了timeout參數(shù)的話）。當(dāng)線程被喚醒并重新占有瑣的時候，程序才會繼續(xù)執(zhí)行下去。

threading.Lock()不允許同一線程多次acquire(), 而RLock允許, 即多次出現(xiàn)acquire和release

上面介紹了這么多理論.下面我們用python提供的threading模塊來實(shí)現(xiàn)一個多線程的程序

threading 提供了兩種調(diào)用方式:

直接調(diào)用

import threading

def func(n): # 定義每個線程要運(yùn)行的函數(shù)
    while n > 0:
        print("當(dāng)前線程數(shù):", threading.activeCount())
        n -= 1
        
for x in range(5):
    t = threading.Thread(target=func, args=(2,))  # 生成一個線程實(shí)例,生成實(shí)例后 并不會啟動,需要使用start命令
    t.start() #啟動線程

繼承式調(diào)用

class MyThread(threading.Thread): # 繼承threading的Thread類
    def __init__(self, num):
        threading.Thread.__init__(self) # 必須執(zhí)行父類的構(gòu)造方法
        self.num = num # 傳入?yún)?shù) num

    def run(self):  # 定義每個線程要運(yùn)行的函數(shù)
        while self.num > 0:
            print("當(dāng)前線程數(shù):", threading.activeCount())
            self.num -= 1

for x in range(5):
    t = MyThread(2) # 生成實(shí)例,傳入?yún)?shù)
    t.start() #啟動線程

兩種方式都可以調(diào)用我們的多線程方法。

運(yùn)行下面的代碼,看看結(jié)果.

import threading
def func(n):
    while n > 0:
        print("當(dāng)前線程數(shù):", threading.activeCount())
        n -= 1
for x in range(5):
    t = threading.Thread(target=func, args=(2,))
    t.start()

print("主線程：", threading.current_thread().name)

運(yùn)行結(jié)果：

當(dāng)前線程數(shù): 2
當(dāng)前線程數(shù): 2
當(dāng)前線程數(shù): 2
當(dāng)前線程數(shù): 2
當(dāng)前線程數(shù): 2
當(dāng)前線程數(shù): 3
當(dāng)前線程數(shù): 3
當(dāng)前線程數(shù): 3
主線程： MainThread
當(dāng)前線程數(shù): 3
當(dāng)前線程數(shù): 3

那我們?nèi)绾巫枞泳€程讓他們運(yùn)行完,在繼續(xù)后面的操作呢.這個時候join()方法就派上用途了. 我們改寫代碼:

import threading

def func(n):
    while n > 0:
        print("當(dāng)前線程數(shù):", threading.activeCount())
        n -= 1

threads = [] #運(yùn)行的線程列表
for x in range(5):
    t = threading.Thread(target=func, args=(2,))
    threads.append(t) # 將子線程追加到列表
    t.start()

for t in threads:
    t.join()

print("主線程：", threading.current_thread().name)

join的原理就是依次檢驗(yàn)線程池中的線程是否結(jié)束，沒有結(jié)束就阻塞直到線程結(jié)束，如果結(jié)束則跳轉(zhuǎn)執(zhí)行下一個線程的join函數(shù)。

先看看這個：

阻塞主進(jìn)程，專注于執(zhí)行多線程中的程序。

多線程多join的情況下，依次執(zhí)行各線程的join方法，前頭一個結(jié)束了才能執(zhí)行后面一個。

無參數(shù)，則等待到該線程結(jié)束，才開始執(zhí)行下一個線程的join。

參數(shù)timeout為線程的阻塞時間，如 timeout=2 就是罩著這個線程2s 以后，就不管他了，繼續(xù)執(zhí)行下面的代碼。

一個進(jìn)程可以開啟多個線程,那么多么多個進(jìn)程操作相同數(shù)據(jù),勢必會出現(xiàn)沖突.那如何避免這種問題呢?

import threading,time

num = 10 #共享變量

def func():
    global num
    lock.acquire() # 加鎖
    num = num - 1
    lock.release() # 解鎖
    print(num)

threads = []
lock = threading.Lock() #生成全局鎖
for x in range(10):
    t = threading.Thread(target=func)
    threads.append(t)
    t.start()

for t in threads:
    t.join()

通過 threading.Lock() 我們可以申請一個鎖。然后 acquire 方法進(jìn)入臨界區(qū).操作完共享數(shù)據(jù) 使用 release 方法退出.

臨界區(qū)的概念： 百度百科

在這里補(bǔ)充一下:Python的Queue模塊是線程安全的.可以不對它加鎖操作.

聰明的同學(xué) 會發(fā)現(xiàn)一個問題? 咱們不是有 GIL 嗎 為什么還要加鎖？

這個問題問的好！我們下一節(jié),將對這個問題進(jìn)行探討.

GIL的鎖是對于一個解釋器，只能有一個thread在執(zhí)行bytecode。所以每時每刻只有一條bytecode在被執(zhí)行一個thread。GIL保證了bytecode 這層面上是線程是安全的.

但是如果你有個操作一個共享 x += 1，這個操作需要多個bytecodes操作，在執(zhí)行這個操作的多條bytecodes期間的時候可能中途就換thread了，這樣就出現(xiàn)了線程不安全的情況了。

總結(jié)：同一時刻CPU上只有單個執(zhí)行流不代表線程安全。

互斥鎖 同時只允許一個線程更改數(shù)據(jù)，而Semaphore是同時允許一定數(shù)量的線程更改數(shù)據(jù) ，比如廁所有3個坑，那最多只允許3個人上廁所，后面的人只能等里面有人出來了才能再進(jìn)去。

import threading,time

num = 10

def func():
    global num
    lock.acquire()
    time.sleep(2)
    num = num - 1
    lock.release()
    print(num)

threads = []
lock = threading.BoundedSemaphore(5) #最多允許5個線程同時運(yùn)行
for x in range(10):
    t = threading.Thread(target=func)
    threads.append(t)
    t.start()

for t in threads:
    t.join()

print("主線程：", threading.current_thread().name)

運(yùn)行一下上面的代碼.你會很明顯的發(fā)現(xiàn) 每次只執(zhí)行五個線程。

淺談多進(jìn)程多線程的選擇： 文章鏈接
python-多線程(原理篇):  文章鏈接
Python有GIL為什么還需要線程同步？:  文章鏈接