腳本之家服務器常用軟件

快捷導航

Python進階之多線程的實現(xiàn)方法總結

更新時間：2023年04月14日 10:30:56 作者：生魚同學

在python中主要有兩種實現(xiàn)多線程的方式：通過threading.Thread?()?方法創(chuàng)建線程和通過繼承?threading.Thread?類的繼承重寫run方法，接下來我們分別說一下多線程的兩種實現(xiàn)形式吧

線程

想要理解線程的含義，首先我們先看一下百度百科的定義：

線程（英語：thread）是操作系統(tǒng)能夠進行運算調度的最小單位。它被包含在進程之中，是進程中的實際運作單位。一條線程指的是進程中一個單一順序的控制流，一個進程中可以并發(fā)多個線程，每條線程并行執(zhí)行不同的任務。

簡單來講，當你打開電腦中的一個應用程序，其實此時計算機就為你創(chuàng)建了一個進程，系統(tǒng)會為其進行資源分配并且對其進行調度。而線程就是比進程還要小的單位，多個線程完成不同的工作組成了我們宏觀上能夠得到響應的工作結果。

舉個例子，進程就像一個大的工廠，工廠中有很多機床設備和場地。而不同的線程就像工廠中工作的工人，工廠為其分配不同的工作來完成一個最終的生產目標。我們可以指派不同的工人做不同的工作或增加工人提高我們的生產效率。

在編程中，線程可以由我們啟用幫助我們完成不同的工作實現(xiàn)多線程并發(fā)，提高我們的代碼效率。

Python中的多線程

在python中主要有兩種實現(xiàn)多線程的方式：

通過threading.Thread () 方法創(chuàng)建線程
通過繼承 threading.Thread 類的繼承重寫run方法

接下來我們分別說一下多線程的兩種實現(xiàn)形式。

threading.Thread () 創(chuàng)建線程

為了更直觀的理解這個過程，首先我們先編寫一個正常的函數(shù)，完成倒數(shù)5個數(shù)的功能，其中間隔一秒鐘。

def fuc():
    for i in range(5):
        time.sleep(1)

在主函數(shù)中，我們調用Thread（）來實例化兩個線程，讓他們同時運行。

if __name__ == '__main__':
    t1 = threading.Thread(target=fuc, args=(1,), daemon=True)
    t2 = threading.Thread(target=fuc, args=(2,), daemon=True)
    t2.start()
    t1.start()

整體代碼如下所示：

import threading
import time


def fuc():
    for i in range(5):
        time.sleep(1)


if __name__ == '__main__':
    t1 = threading.Thread(target=fuc)
    t2 = threading.Thread(target=fuc)
    t2.start()
    t1.start()

我們先不討論調用的函數(shù)以及傳入的參數(shù)，先來看一下運行效果：

0
0
11
22
33
44

可以看到，兩個打印的結果基本上是同時出現(xiàn)的，并且出現(xiàn)了混合的情況，證明兩個打印的函數(shù)正在同時進行。

接下來我們就來介紹一下類的初始化參數(shù)以及我們調用的函數(shù)：

thread.Thread(group=Nore,targt=None,args=(),kwargs={},*,daemon=None)

在該類中主要由以下幾個參數(shù)組成：

group：與ThreadGroup類相關，一般不使用。
target：線程調用的對象，就是目標函數(shù)，在上述的例子中我們傳入的是我們編寫的函數(shù)fuc。
name：線程的名字，默認是Tread-x。
args：為目標函數(shù)傳遞關鍵字參數(shù)，字典。
daemon：用來設置線程是否隨主線程退出而退出，涉及到主線程相關知識，我們稍后介紹。

接下來介紹我們常用的幾個方法：

run（）：表示線程啟動的活動，在第二種繼承寫法中會用到。
start（）：激活線程，使其能夠被調度。
join（）：等待至線程終止，這個方法涉及到主線程的知識，我們稍后介紹。
isAlive（）：返回線程是否活動。
getName（）：返回線程名稱。
setName() : 設置線程名稱。

接下來，我們使用上述參數(shù)更改示例，讓函數(shù)獲取一個參數(shù)，并為不同的線程設置名字。代碼如下：

import threading
import time


def fuc(num):
    for i in range(5):
        print('接收到參數(shù){}：'.format(num), i)
        time.sleep(1)


if __name__ == '__main__':
	# 傳入參數(shù)及名字
    t1 = threading.Thread(target=fuc, args=(1,), name='t1')
    t2 = threading.Thread(target=fuc, args=(2,), name='t2')
    t1.start()
    print(t1.getName(), '開始運行...')
    t2.start()
    print(t2.getName(), '開始運行...')

運行結果如下：

接收到參數(shù)1：t1 開始運行...
0
接收到參數(shù)2： t20 開始運行...

接收到參數(shù)1：接收到參數(shù)2： 1
1
接收到參數(shù)1：接收到參數(shù)2： 2
2
接收到參數(shù)1：接收到參數(shù)2： 33

接收到參數(shù)1：接收到參數(shù)2： 4
4

可以看到，雖然結果很混亂，但是我們傳入的參數(shù)以及獲取的名字都被打印出來了。

另外，這里有兩個注意：

trgat參數(shù)接受的是函數(shù)名字不需要加括號。
args傳入的執(zhí)行函數(shù)參數(shù)要加括號和逗號，保證其是一個元組。

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

在上面的例子中，我們已經理解了多線程的一種創(chuàng)建方法。接下來我們來介紹第二種方法，這也是眾多大佬很喜歡的一種方法，通過繼承 threading.Thread 類的線程創(chuàng)建。

class MyThread(threading.Thread):
    def run(self) -> None:
        for i in range(5):
            print(i)
            time.sleep(1)


if __name__ == '__main__':
    t1 = MyThread(name='t1')
    t2 = MyThread(name='t2')
    t1.start()
    t2.start()

運行結果如下：

0
0
11
22
33
44

注意：這里調用的是start方法而不是run方法，否則會編程單線程執(zhí)行。

主線程

在了解了多線程的編程方法之后，我們來介紹一下主線程及相關參數(shù)和方法。

在我們執(zhí)行多線程程序的過程中，存在一個主線程，而我們開辟的其他線程其實都是它的子線程。由主線程主導的工作有以下兩種情況：

由于主線程結束了，強制停止其它線程的工作，但此時其他線程有可能還沒有結束自己的工作。
主線程結束后，等待其他線程結束工作，再停止所有線程的工作。

可以簡單地理解為包工頭，它是這些線程的頭子！其從微觀角度上講掌管了一定的工作流程，它可以選擇是否等待其它工人結束工作再結束整個工作。

而我們可以使用參數(shù)或者方法控制這個過程。

使用daemon參數(shù)控制過程

在上邊的函數(shù)參數(shù)介紹中，提到了daemon參數(shù)，其為False時，線程不會隨主線程結束而退出，主線程會等待其結束后再退出。而為True時則不論子線程是否完成了相關工作都會直接退出。

接下來我們看兩個示例，我們修改剛才的示例代碼的daemon參數(shù)為True，表示不論子線程是否完成了工作都強制退出。

import threading
import time


def fuc(num):
    for i in range(5):
        print('接收到參數(shù){}：'.format(num), i)
        time.sleep(1)


if __name__ == '__main__':
    t1 = threading.Thread(target=fuc, args=(1,), name='t1', daemon=True)
    t2 = threading.Thread(target=fuc, args=(2,), name='t2', daemon=True)
    t1.start()
    print(t1.getName(), '開始運行...')
    t2.start()
    print(t2.getName(), '開始運行...')
    print("我是主線程，都給我停下！")

結果如下：

接收到參數(shù)1：t1 0
開始運行...
接收到參數(shù)2：t2 0
開始運行...
我是主線程，都給我停下！

可以看到，子線程的倒數(shù)還沒有結束，由于主線程結束了，所有線程一起結束了。這里要注意以下幾點：

daemon屬性必須在start( )之前設置。
從主線程創(chuàng)建的所有線程不設置daemon屬性，則默認都是daemon=False。

使用.join()阻塞線程

除此之外，我們還可以調用.join()方法阻塞線程，調用該方法的時候，該方法的調用者線程結束后程序才會終止。

#timeout參數(shù)表明等待的時長，不設置該參數(shù)則默認為一直等待。
join(timeout-=None)

我們來看下面這個示例，我們更改了兩個函數(shù)的倒計時時間，使第一個線程的倒計時時間更長，并對第二個線程進行了阻塞操作。代碼如下：

import threading
import time


def fuc1():
    for i in range(10):
        print(i)
        time.sleep(1)


def fuc2():
    for i in range(5):
        print(i)
        time.sleep(1)


if __name__ == '__main__':
    t1 = threading.Thread(target=fuc1, name='t1', daemon=True)
    t2 = threading.Thread(target=fuc2, name='t2', daemon=True)
    t1.start()
    print(t1.getName(), '開始運行...')
    print('我是二兒子，等等我！')
    t2.start()
    print(t2.getName(), '開始運行...')
    t2.join()
    print("我是主線程，都給我停下！")

結果如下：

0t1
開始運行...
我是二兒子，等等我！
0t2
開始運行...
11
22
33
44

我是主線程，都給我停下！5

我們可以看到，上述代碼中線程一還沒有結束倒數(shù)十個數(shù)，程序就結束了。在此過程中，主線程只等待了第二個線程結束，整個程序就結束了。

線程同步

在多個線程同步運行的情況下，會出現(xiàn)多個線程同時操作一個數(shù)據(jù)的情況。如果兩個線程同時操作同一個變量的話，很容易出現(xiàn)混亂的情況。所以，我們需要一個工具來確保在同一時間只能有一個線程處理數(shù)據(jù)。

線程類提供了鎖來解決問題，當線程申請?zhí)幚砟硞€數(shù)據(jù)時申請一個鎖來控制住當前數(shù)據(jù)，結束處理時即將鎖釋放。

threading中的鎖

python的threading中為我們提供了RLock鎖來解決多線程同時處理一個數(shù)據(jù)的問題。在某個時刻，我們可以讓線程申請鎖來保護數(shù)據(jù)此時只能供該線程使用。

為了更好的理解該過程，我們定義一個全局變量，讓每一個線程都對其操作但不設置鎖，觀察變量的變化：

R_LOCK = threading.Lock()
COUNT = 100


class MyThread(threading.Thread):
    def run(self) -> None:
        global COUNT
        #R_LOCK.acquire()
        COUNT -= 10
        time.sleep(1)
        print(self.getName(), COUNT)
        #R_LOCK.release()


if __name__ == '__main__':
    threads = [MyThread() for i in range(10)]
    for t in threads:
        t.start()

結果如下：