Python 到底是 執行緒快🚀 還是 行程快🚀

前言

在探究這個 Python 中 到底是 執行緒快 還是 行程快 前，有必要先了解一下CPython的GIL鎖，這非常重要，關系到執行緒呼叫的機制，以及Python運行速度慢的原因之一

GIL全域解釋器鎖

GIL 全程 Global Interpreter Lock，中文釋義 全域解釋器鎖，得先知道的是，這不是Python獨有的特性，它只是在實作CPython（Python解釋器）時，引入的一個概念

官方對此的描述

In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple
native threads from executing Python bytecodes at once. This lock is necessary mainly
because CPython’s memory management is not thread-safe. (However, since the GIL
exists, other features have grown to depend on the guarantees that it enforces.)

中文翻譯

在CPython中，全域解釋器鎖或GIL是互斥鎖，可防止多個
本地執行緒一次執行Python位元組碼， 這個鎖主要是必要的
因為CPython的記憶體管理不是執行緒安全的， （但是，自GIL
存在，其他功能也越來越依賴于它所執行的保證，）

簡單的來說，就是在Cpython解釋器中，同一個行程下開啟多執行緒，由于GIL是一個互斥鎖（mutex），阻止了多個執行緒在同一個行程內的同時執行，同一時刻的同一行程只能有一個執行緒在執行，毫無疑問，這降低了執行效率，那為什么還要有GIL的存在呢，要明白GIL的必要性，就需要了解CPython對于執行緒安全的 記憶體管理機制

執行緒快 還是 行程快 這得看應用場景，這里直接說答案，對于 計算密集型 的任務來說，多行程更快；對于 IO密集型 的任務來說，多執行緒更快

IO密集型

IO 是 Input/Output 的縮寫，說白就是 對資料對讀取和寫入，那IO密集型，就是大部分在對資料 讀取和寫入 的程式系統（硬碟讀寫、網路傳輸等）

之前提到了由于 GIL全域解釋器鎖 的存在，同一時刻同一行程中只有一個執行緒在執行，對于這種想要等的IO操作來說，開再多的行程效果也不大，且開行程的開銷較大，還不如多開執行緒，效率反而高點

性能測驗
對于IO密集型程式來說，多執行緒下和多行程下的分別耗時統計

多行程

from multiprocessing import Process


class MyProcess(Process):

    def sleep(self):
        print(f"{self.name} 正在執行")
        time.sleep(2)

    def run(self) -> None:
        self.sleep()


if __name__ == '__main__':
    start_time = time.time()
    pro_list = []
    for i in range(10):
        p = MyProcess()
        p.start()
        pro_list.append(p)

    for i in pro_list:
        i.join()
    print(f"耗費時間: {time.time() - start_time}")

開啟十個行程下，耗時為：2.734959363937378（每次運行不一樣很正常，這里僅作參考）

多執行緒

from threading import Thread


class MyProcess(Thread):

    def sleep(self):
        print(f"{self.name} 正在執行")
        time.sleep(2)

    def run(self) -> None:
        self.sleep()


if __name__ == '__main__':
    start_time = time.time()
    thr_list = []
    for i in range(10):
        t = MyProcess()
        t.start()
        thr_list.append(t)

    for i in thr_list:
        i.join()
    print(f"耗費時間: {time.time() - start_time}")

開啟十個執行緒下，耗時為：2.0112526416778564（每次運行不一樣很正常，這里僅作參考）

計算密集型

程式系統大部分在做 資料計算、邏輯判斷、回圈等，為計算密集型，比如：1+2+3…+10000000

雖然說由于 GIL全域解釋器鎖 的存在，用不到真正的多執行緒，但可以開多行程呀，隨著cpu的增多執行效率肯定會有所提高，但有種特殊情況是，然后電腦只有單核的情況下，沒有多核來并行計算，徒增了創建行程的開銷，多行程對單核來說不管用，不過話說回來，都已經這個時代了，單核的電腦我是沒再見到過🤣

性能測驗
對于計算密集型程式來說，多執行緒下和多行程下的分別耗時統計

多行程

class MyProcess(Process):

    def sleep(self):
        print(f"{self.name} 正在執行")
        num = 0
        while num < 10000000:
            num += 1

    def run(self) -> None:
        self.sleep()


if __name__ == '__main__':
    start_time = time.time()
    pro_list = []
    for i in range(10):
        p = MyProcess()
        p.start()
        pro_list.append(p)

    for i in pro_list:
        i.join()
    print(f"耗費時間: {time.time() - start_time}")

開啟十個執行緒下，耗時為：1.843491792678833（每次運行不一樣很正常，這里僅作參考）

多執行緒

class MyProcess(Thread):

    def sleep(self):
        print(f"{self.name} 正在執行")
        num = 0
        while num < 10000000:
            num += 1

    def run(self) -> None:
        self.sleep()


if __name__ == '__main__':
    start_time = time.time()
    thr_list = []
    for i in range(10):
        t = MyProcess()
        t.start()
        thr_list.append(t)

    for i in thr_list:
        i.join()
    print(f"耗費時間: {time.time() - start_time}")

開啟十個執行緒下，耗時為：3.725153923034668（每次運行不一樣很正常，這里僅作參考）

相關博客

Python threading 開啟執行緒