前言

幾乎所有的操作系統(tǒng)都支持同時運(yùn)行多個任務(wù)，每個任務(wù)通常是一個程序，每一個運(yùn)行中的程序就是一個進(jìn)程，即進(jìn)程是應(yīng)用程序的執(zhí)行實(shí)例。現(xiàn)代的操作系統(tǒng)幾乎都支持多進(jìn)程并發(fā)執(zhí)行。注意，并發(fā)和并行是兩個概念，并行指在同一時刻有多條指令在多個處理器上同時執(zhí)行；并發(fā)是指在同一時刻只能有一條指令執(zhí)行，但多個進(jìn)程指令被快速輪換執(zhí)行，使得在宏觀上具有多個進(jìn)程同時執(zhí)行的效果。
例如，程序員一邊開著開發(fā)工具在寫程序，一邊開著參考手冊備查，同時還使用電腦播放音樂……除此之外，每臺電腦運(yùn)行時還有大量底層的支撐性程序在運(yùn)行……這些進(jìn)程看上去像是在同時工作。但事實(shí)的真相是，對于一個 CPU 而言，在某個時間點(diǎn)它只能執(zhí)行一個程序。也就是說，只能運(yùn)行一個進(jìn)程，CPU 不斷地在這些進(jìn)程之間輪換執(zhí)行。那么，為什么用戶感覺不到任何中斷呢？這是因?yàn)橄鄬θ说母杏X來說，CPU 的執(zhí)行速度太快了（如果啟動的程序足夠多，則用戶依然可以感覺到程序的運(yùn)行速度下降了）。所以，雖然 CPU 在多個進(jìn)程之間輪換執(zhí)行，但用戶感覺到好像有多個進(jìn)程在同時執(zhí)行。

線程是進(jìn)程的組成部分，一個進(jìn)程可以擁有多個線程。在多線程中，會有一個主線程來完成整個進(jìn)程從開始到結(jié)束的全部操作，而其他的線程會在主線程的運(yùn)行過程中被創(chuàng)建或退出。當(dāng)進(jìn)程被初始化后，主線程就被創(chuàng)建了，對于絕大多數(shù)的應(yīng)用程序來說，通常僅要求有一個主線程，但也可以在進(jìn)程內(nèi)創(chuàng)建多個順序執(zhí)行流，這些順序執(zhí)行流就是線程。當(dāng)一個進(jìn)程里只有一個線程時，叫作單線程。超過一個線程就叫作多線程。每個線程必須有自己的父進(jìn)程，且它可以擁有自己的堆棧、程序計數(shù)器和局部變量，但不擁有系統(tǒng)資源，因?yàn)?strong>它和父進(jìn)程的其他線程共享該進(jìn)程所擁有的全部資源。線程可以完成一定的任務(wù)，可以與其他線程共享父進(jìn)程中的共享變量及部分環(huán)境，相互之間協(xié)同完成進(jìn)程所要完成的任務(wù)。多個線程共享父進(jìn)程里的全部資源，會使得編程更加方便，需要注意的是，要確保線程不會妨礙同一進(jìn)程中的其他線程。線程是獨(dú)立運(yùn)行的，它并不知道進(jìn)程中是否還有其他線程存在。線程的運(yùn)行是搶占式的，也就是說，當(dāng)前運(yùn)行的線程在任何時候都可能被掛起，以便另外一個線程可以運(yùn)行。多線程也是并發(fā)執(zhí)行的，即同一時刻，Python 主程序只允許有一個線程執(zhí)行，這和全局解釋器鎖有關(guān)系，后續(xù)會做詳細(xì)介紹。
一個線程可以創(chuàng)建和撤銷另一個線程，同一個進(jìn)程中的多個線程之間可以并發(fā)運(yùn)行。從邏輯的角度來看，多線程存在于一個應(yīng)用程序中，讓一個應(yīng)用程序可以有多個執(zhí)行部分同時執(zhí)行，但操作系統(tǒng)無須將多個線程看作多個獨(dú)立的應(yīng)用，對多線程實(shí)現(xiàn)調(diào)度和管理以及資源分配，線程的調(diào)度和管理由進(jìn)程本身負(fù)責(zé)完成。

簡而言之，進(jìn)程和線程的關(guān)系是這樣的：操作系統(tǒng)可以同時執(zhí)行多個任務(wù)，每一個任務(wù)就是一個進(jìn)程，進(jìn)程可以同時執(zhí)行多個任務(wù)，每一個任務(wù)就是一個線程。

Python創(chuàng)建線程 threading

Python 中，有關(guān)線程開發(fā)的部分被單獨(dú)封裝到了模塊中，和線程相關(guān)的模塊有以下 2 個：
???_thread???：是 Python 3 以前版本中 thread 模塊的重命名，此模塊僅提供了低級別的、原始的線程支持，以及一個簡單的鎖。功能比較有限。正如它的名字所暗示的（以 _ 開頭），一般不建議使用 thread 模塊；
???threading??：Python 3 之后的線程模塊，提供了功能豐富的多線程支持，推薦使用。

本節(jié)就以 threading 模塊為例進(jìn)行講解。Python 主要通過兩種方式來創(chuàng)建線程：

• 使用 threading 模塊中 Thread 類的構(gòu)造器創(chuàng)建線程。即直接對類 threading.Thread 進(jìn)行實(shí)例化創(chuàng)建線程，并調(diào)用實(shí)例化對象的 start() 方法啟動線程。
• 繼承 threading 模塊中的 Thread 類創(chuàng)建線程類。即用 threading.Thread 派生出一個新的子類，將新建類實(shí)例化創(chuàng)建線程，并調(diào)用其 start() 方法啟動線程。

調(diào)用Thread類的構(gòu)造器創(chuàng)建線程

Thread 類提供了如下的 ??__init__()???構(gòu)造器，可以用來創(chuàng)建線程：??__init__(self, group=None, target=None, name=None, args=(), kwargs=None, *,daemon=None)?? 此構(gòu)造方法中，以上所有參數(shù)都是可選參數(shù)，即可以使用，也可以忽略。其中各個參數(shù)的含義如下：

• group：指定所創(chuàng)建的線程隸屬于哪個線程組（此參數(shù)尚未實(shí)現(xiàn)，無需調(diào)用）；
• target：指定所創(chuàng)建的線程要調(diào)度的目標(biāo)方法（最常用）；
• args：以元組的方式，為 target 指定的方法傳遞參數(shù)；
• kwargs：以字典的方式，為 target 指定的方法傳遞參數(shù)；
• daemon：指定所創(chuàng)建的線程是否為后代線程。
  這些參數(shù)，初學(xué)者只需記住 target、args、kwargs 這 3 個參數(shù)的功能即可。

下面程序演示了如何使用 Thread 類的構(gòu)造方法創(chuàng)建一個線程：

import threading
#定義線程要調(diào)用的方法，*add可接收多個以非關(guān)鍵字方式傳入的參數(shù)
def action(*add):
for arc in add:
#調(diào)用 getName() 方法獲取當(dāng)前執(zhí)行該程序的線程名
print(threading.current_thread().getName() +" "+ arc)
#定義為線程方法傳入的參數(shù)
my_tuple = ("http://c.biancheng.net/python/",\
"http://c.biancheng.net/shell/",\
"http://c.biancheng.net/java/")
#創(chuàng)建線程
thread = threading.Thread(target = action,args =my_tuple)

有關(guān) Thread 類提供的和線程有關(guān)的方法，可閱讀???Python Thread手冊???，由于不是本節(jié)重點(diǎn)，這里不再進(jìn)行詳細(xì)介紹。
由此就創(chuàng)建好了一個線程。但是線程需要手動啟動才能運(yùn)行，threading 模塊提供了 start() 方法用來啟動線程。因此在上面程序的基礎(chǔ)上，添加如下語句：thread.start()
再次執(zhí)行程序，

其輸出結(jié)果為：

Thread-1 http://c.biancheng.net/python/
Thread-1 http://c.biancheng.net/shell/
Thread-1 http://c.biancheng.net/java/

可以看到，新創(chuàng)建的 thread 線程（線程名為 Thread-1）執(zhí)行了 action() 函數(shù)。
默認(rèn)情況下，主線程的名字為 MainThread，用戶啟動的多個線程的名字依次為 Thread-1、Thread-2、Thread-3、…、Thread-n 等。

為了使 thread 線程的作用更加明顯，可以繼續(xù)在上面程序的基礎(chǔ)上添加如下代碼，讓主線程和新創(chuàng)建線程同時工作：

for i in range(5):
print(threading.current_thread().getName())

再次執(zhí)行程序，其輸出結(jié)果為：

MainThreadThread-1 http://c.biancheng.net/python/
MainThreadThread-1 http://c.biancheng.net/shell/
MainThreadThread-1 http://c.biancheng.net/java/
MainThread
MainThread

可以看到，當(dāng)前程序中有 2 個線程，分別為主線程 MainThread 和子線程 Thread-1，它們以并發(fā)方式執(zhí)行，即 Thread-1 執(zhí)行一段時間，然后 MainThread 執(zhí)行一段時間。通過輪流獲得 CPU 執(zhí)行一段時間的方式，程序的執(zhí)行在多個線程之間切換，從而給用戶一種錯覺，即多個線程似乎同時在執(zhí)行。
如果程序中不顯式創(chuàng)建任何線程，則所有程序的執(zhí)行，都將由主線程 MainThread 完成，程序就只能按照順序依次執(zhí)行。

繼承Thread類創(chuàng)建線程類

通過繼承 Thread 類，我們可以自定義一個線程類，從而實(shí)例化該類對象，獲得子線程。需要注意的是，在創(chuàng)建 Thread 類的子類時，必須重寫從父類繼承得到的 run() 方法。因?yàn)樵摲椒礊橐獎?chuàng)建的子線程執(zhí)行的方法，其功能如同第一種創(chuàng)建方法中的 action() 自定義函數(shù)。

下面程序，演示了如何通過繼承 Thread 類創(chuàng)建并啟動一個線程：

import threading
#創(chuàng)建子線程類，繼承自 Thread 類
class my_Thread(threading.Thread):
def __init__(self,add):
threading.Thread.__init__(self)
self.add = add
# 重寫run()方法
def run(self):
for arc in self.add:
#調(diào)用 getName() 方法獲取當(dāng)前執(zhí)行該程序的線程名
print(threading.current_thread().getName() +" "+ arc)
#定義為 run() 方法傳入的參數(shù)
my_tuple = ("http://c.biancheng.net/python/",\
"http://c.biancheng.net/shell/",\
"http://c.biancheng.net/java/")
#創(chuàng)建子線程
mythread = my_Thread(my_tuple)
#啟動子線程
mythread.start()
#主線程執(zhí)行此循環(huán)
for i in range(5):
print(threading.current_thread().getName())

程序執(zhí)行結(jié)果為：

MainThreadThread-1 http://c.biancheng.net/python/
MainThreadThread-1 http://c.biancheng.net/shell/
MainThreadThread-1 http://c.biancheng.net/java/
MainThread
MainThread

此程序中，子線程 Thread-1 執(zhí)行的是 run() 方法中的代碼，而 MainThread 執(zhí)行的是主程序中的代碼，它們以快速輪換 CPU 的方式在執(zhí)行。

Thread join()用法

如何通過 Thread 類創(chuàng)建并啟動一個線程，當(dāng)時給讀者用如下的程序進(jìn)行演示：

import threading
#定義線程要調(diào)用的方法，*add可接收多個以非關(guān)鍵字方式傳入的參數(shù)
def action(*add):
    for arc in add:
        #調(diào)用 getName() 方法獲取當(dāng)前執(zhí)行該程序的線程名
        print(threading.current_thread().getName() +" "+ arc)
#定義為線程方法傳入的參數(shù)
my_tuple = ("http://c.biancheng.net/python/",\
            "http://c.biancheng.net/shell/",\
            "http://c.biancheng.net/java/")
#創(chuàng)建線程
thread = threading.Thread(target = action,args =my_tuple)
#啟動線程
thread.start()
#主線程執(zhí)行如下語句
for i in range(5):
    print(threading.current_thread().getName())

程序執(zhí)行結(jié)果為（不唯一）：

Thread-1 http://c.biancheng.net/python/MainThread
Thread-1 http://c.biancheng.net/shell/MainThread
Thread-1 http://c.biancheng.net/java/MainThread
MainThread
MainThread

可以看到，我們用 Thread 類創(chuàng)建了一個線程（線程名為 Thread-1），其任務(wù)是執(zhí)行 action() 函數(shù)。同時，我們也給主線程 MainThread 安排了循環(huán)任務(wù)（第 16、17 行）。通過前面的學(xué)習(xí)我們知道，主線程 MainThread 和子線程 Thread-1 會輪流獲得 CPU 資源，因此該程序的輸出結(jié)果才會向上面顯示的這樣。
但是，如果我們想讓 Thread-1 子線程先執(zhí)行，然后再讓 MainThread 執(zhí)行第 16、17 行代碼，該如何實(shí)現(xiàn)呢？很簡單，通過調(diào)用線程對象的 join() 方法即可。
join() 方法的功能是在程序指定位置，優(yōu)先讓該方法的調(diào)用者使用 CPU 資源。該方法的語法格式如下：thread.join( [timeout] )

其中，thread 為 Thread 類或其子類的實(shí)例化對象；timeout 參數(shù)作為可選參數(shù)，其功能是指定 thread 線程最多可以霸占 CPU 資源的時間（以秒為單位），如果省略，則默認(rèn)直到 thread 執(zhí)行結(jié)束（進(jìn)入死亡狀態(tài)）才釋放 CPU 資源。

舉個例子，修改上面的代碼，如下所示：

import threading
#定義線程要調(diào)用的方法，*add可接收多個以非關(guān)鍵字方式傳入的參數(shù)
def action(*add):
for arc in add:
#調(diào)用 getName() 方法獲取當(dāng)前執(zhí)行該程序的線程名
print(threading.current_thread().getName() +" "+ arc)
#定義為線程方法傳入的參數(shù)
my_tuple = ("http://c.biancheng.net/python/",\
"http://c.biancheng.net/shell/",\
"http://c.biancheng.net/java/")
#創(chuàng)建線程
thread = threading.Thread(target = action,args =my_tuple)
#啟動線程
thread.start()
#指定 thread 線程優(yōu)先執(zhí)行完畢
thread.join()
#主線程執(zhí)行如下語句
for i in range(5):
print(threading.current_thread().getName())

程序執(zhí)行結(jié)果為：

Thread-1 http://c.biancheng.net/python/
Thread-1 http://c.biancheng.net/shell/
Thread-1 http://c.biancheng.net/java/
MainThread
MainThread
MainThread
MainThread
MainThread

程序中第 16 行的位置，thread 線程調(diào)用了 join() 方法，并且沒有指定具體的 timeout 參數(shù)值。這意味著如果程序想繼續(xù)往下執(zhí)行，必須先執(zhí)行完 thread 線程。