併發和並行 | Python中實現多執行緒 threading 和多程序 multiprocessing

昨天晚上組會輪到我彙報技術內容，最近正在和 ray 以及 spark 打交道，索性講一下併發和並行。反正大家都是管理學院的，平時很少接觸這種，因此這個選題不大可能因為內容基礎而貽笑大方。

本文擺一擺併發和並行。附上很簡單的 Python 程式碼，涉及到自帶庫 threading 和 multiprocessing 的使用。

併發和並行

咱們簡單用多執行緒對應併發，多程序對應並行。多執行緒併發更強調充分利用效能；多程序並行更強調提升效能上限。

我用非常簡單且不那麼嚴謹的比喻來說明。

多執行緒

一個 CPU 相當於一個學生。

一個學生一週開一次組會，換句話說一週給老師彙報一次工作。

老師一般會給學生同時佈置幾個任務，比如做比賽、做專案、讀論文，學生可能週一做做比賽、週二讀讀論文、週三做做專案... 到了組會，他就把三件事都拿出來彙報，老師很欣慰，因為在老師的視角里：學生這三件事是同時在做的。

多執行緒也是同一個道理，假設你的手機只有一塊單核 CPU 。你的 CPU 這 0.01 秒用來播放音樂，下 0.01 秒用來解析網頁... 在你的視角里：播放音樂和解析網頁是同時進行的。你大可以暢快地邊聽音樂邊網上衝浪

何謂充分利用效能？ 如果這學生只有一項工作，那他這一週可能只需要花費兩天來做任務，剩下時間摸魚（針不搓，三點鐘飲茶先！）。因此，我們用「多執行緒」來讓學生實現『併發』，充分利用學生能力。

在實際情況中，多執行緒、高併發這些詞語更多地出現在服務端程式裡。比如一個網路連線由一個執行緒負責，一塊 CPU 可以負責處理多個非同步的請求，大大提升了 CPU 利用率。

多程序

多個 CPU （ CPU 的多核）相當於多個學生。

一個任務可以拆成幾個任務相互協作、同時進行，則是多程序。

比如研究生課程，老師非得留個論文作業，都研究生了我去，留啥大作業。

那咱就多執行緒並行搞唄。確定了大概思路，剩下的一股腦寫就行。咱隊伍裡一共甲乙丙丁四名同學，那就：

• 甲同學負責 Introduction
• 乙同學負責 Background
• 丙同學負責 Related Works
• 丁同學負責 Methodology

這是乙同學提出異議：不應該是先完成 Introduction 再寫 Background ，一個個來嘛？

大哥，都研究生了嗷，作業糊弄糊弄差不多得了啊。讓你寫你就寫。

可以預知，上述四部分同時進行，怎麼也比一個人寫四塊要快。

所以說 多程序並行提升效能上限 。

在實際情況中，多程序更多地與高效能運算、分散式計算聯絡在一起。

Python 實現

首先宣告咱的實驗環境。

> python --version
Python 3.8.5

咱們設定個任務：求數的尤拉函式值。

def euler_func(n: int) -> int:
    res = n
    i = 2
    while i <= n // i:
        if n % i == 0:
            res = res // i * (i - 1)
            while (n % i == 0): n = n // i
        i += 1
    if n > 1:
        res = res // n * (n - 1)
    return res

求一個數的尤拉函式值可能很快，但是一堆數呢？

所以咱想著用並行完成這個任務。

咱們把任務分成三份。

task1 = list(range(2, 50000, 3))  # 2, 5, ...
task2 = list(range(3, 50000, 3))  # 3, 6, ...
task3 = list(range(4, 50000, 3))  # 4, 7, ...

def job(task: List):
    for t in task:
        euler_func(t)

來看看平平無奇的正常序列。

@timer
def normal():
    job(task1)
    job(task2)
    job(task3)

完成了 task1 再完成 task2 ... 行，沒毛病。

看看多執行緒？

import threading as th

@timer
def mutlthread():
    th1 = th.Thread(target=job, args=(task1, ))
    th2 = th.Thread(target=job, args=(task2, ))
    th3 = th.Thread(target=job, args=(task3, ))

    th1.start()
    th2.start()
    th3.start()

    th1.join()
    th2.join()
    th3.join()

再看看多程序？

import multiprocessing as mp

@timer
def multcore():
    p1 = mp.Process(target=job, args=(task1, ))
    p2 = mp.Process(target=job, args=(task2, ))
    p3 = mp.Process(target=job, args=(task3, ))

    p1.start()
    p2.start()
    p3.start()

    p1.join()
    p2.join()
    p3.join()

上述程式碼的邏輯是這樣的：

• 我建立執行緒/程序，其生來的目的就是完成任務job(task1)或job(task2)、job(task3)，注意這裡函式名和引數被分開了target=job, args=(task1, )
• 然後 start() ，告訴執行緒/程序：你可以開始幹活了
• 他們自己幹自己的，咱們程式主邏輯還得繼續往下執行
• 到 join() 這裡，咱們是指讓執行緒/程序阻塞住咱的主邏輯，比如p1.join()是指：p1不幹完活，我主邏輯不往下進行（屬於是「阻塞」）
• 這樣，我們的函式multcore結束後，一定其中的執行緒/程序任務都完成了

咱看看結果：

if __name__ == '__main__':

    print("同步序列：")
    normal()

    print("多執行緒併發：")
    mutlthread()

    print("多程序並行：")
    multcore()

# 下面是結果
同步序列：
timer: using 0.24116 s
多執行緒併發：
timer: using 0.24688 s
多程序並行：
timer: using 0.13791 s

結果不太對，按理說，多程序並行的耗時應該是同步序列的三分之一，畢竟三個同等體量的任務在同時進行。

多執行緒併發比同步序列慢是應該的，因為多執行緒併發和同步序列的算力是一樣的，但是多執行緒併發得在各個任務間來回切換，導致更慢。

你問 @timer 是什麼意思？哦，這個是我寫的修飾器，如下。

def timer(func):
    @wraps(func)
    def inner_func():
        t = time.time()
        rts = func()
        print(f"timer: using {time.time() - t :.5f} s")
        return rts
    return inner_func

不太明白『Python修飾器』的老鐵，不如給我點個「在看」，再關注下我，咱們以後詳細道來。

我是小拍，微信 PiperLHJ ，感謝關注與在看。