Python併發程式設計之從效能角度來初探併發程式設計（一）

. 本文目錄

• 前言
• 併發程式設計的基本概念
• 單執行緒VS多執行緒VS多程式
• 效能對比成果總結

. 前言

作為進階系列的一個分支「併發程式設計」，我覺得這是每個程式設計師都應該會的。

併發程式設計 這個系列，我準備了將近一個星期，從知識點梳理，到思考要舉哪些例子才能更加讓人容易吃透這些知識點。希望呈現出來的效果真能如想象中的那樣，對小白也一樣的友好。

昨天大致整理了下，這個系列我大概會講如下內容（後期可能調整）：

課程大綱

對於併發程式設計，Python的實現，總結了一下，大致有如下三種方法：

• 多執行緒
• 多程式
• 協程（生成器）

在之後的章節裡，將陸陸續續地給大家介紹到這三個知識點。

. 併發程式設計的基本概念

在開始講解理論知識之前，先過一下幾個基本概念。雖然我們是進階教程，但我也希望寫得更小白，更通俗易懂。

序列：一個人在同一時間段只能幹一件事，譬如吃完飯才能看電視；
並行：一個人在同一時間段可以幹多件事，譬如可以邊吃飯邊看電視；

在Python中，多執行緒 和 協程 雖然是嚴格上來說是序列，但卻比一般的序列程式執行效率高得很。
一般的序列程式，在程式阻塞的時候，只能乾等著，不能去做其他事。就好像，電視上播完正劇，進入廣告時間，我們卻不能去趁廣告時間是吃個飯。對於程式來說，這樣做顯然是效率極低的，是不合理的。

當然，學完這個課程後，我們就懂得，利用廣告時間去做其他事，靈活安排時間。這也是我們多執行緒和協程 要幫我們要完成的事情，內部合理排程任務，使得程式效率最大化。

雖然 多執行緒 和 協程 已經相當智慧了。但還是不夠高效，最高效的應該是一心多用，邊看電視邊吃飯邊聊天。這就是我們的 多程式 才能做的事了。

為了更幫助大家更加直觀的理解，在網上找到兩張圖，來生動形象的解釋了多執行緒和多程式的區別。（侵刪）

• 多執行緒，交替執行，另一種意義上的序列。
  

  

• 多程式，並行執行，真正意義上的併發。
  

  

. 單執行緒VS多執行緒VS多程式

文字總是蒼白無力的，千言萬語不如幾行程式碼來得孔武有力。

首先，我的實驗環境配置如下

注意
以下程式碼，若要理解，對小白有如下知識點要求:

1. 裝飾器的運用
2. 多執行緒的基本使用
3. 多程式的基本使用

當然，看不懂也沒關係，主要最後的結論，能讓大家對單執行緒、多執行緒、多程式在實現效果上有個大體清晰的認識，達到這個效果，本文的使命也就完成了，等到最後，學完整個系列，不妨再回頭來理解也許會有更深刻的理解。

下面我們來看看，單執行緒，多執行緒和多程式，在執行中究竟孰強孰弱。

開始對比之前，首先定義四種型別的場景

• CPU計算密集型
• 磁碟IO密集型
• 網路IO密集型
• 【模擬】IO密集型

為什麼是這幾種場景，這和多執行緒 多程式的適用場景有關。結論裡，我再說明。

# CPU計算密集型
def count(x=1, y=1):
    # 使程式完成150萬計算
    c = 0
    while c < 500000:
        c += 1
        x += x
        y += y


# 磁碟讀寫IO密集型
def io_disk():
    with open("file.txt", "w") as f:
        for x in range(5000000):
            f.write("python-learning\n")


# 網路IO密集型
header = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3359.139 Safari/537.36'}
url = "https://www.tieba.com/"

def io_request():
    try:
        webPage = requests.get(url, headers=header)
        html = webPage.text
        return
    except Exception as e:
        return {"error": e}


# 【模擬】IO密集型
def io_simulation():
    time.sleep(2)
複製程式碼

比拼的指標，我們用時間來考量。時間耗費得越少，說明效率越高。

為了方便，使得程式碼看起來，更加簡潔，我這裡先定義是一個簡單的 時間計時器 的裝飾器。
如果你對裝飾器還不是很瞭解，也沒關係，你只要知道它是用於 計算函式執行時間的東西就可以了。

def timer(mode):
    def wrapper(func):
        def deco(*args, **kw):
            type = kw.setdefault('type', None)
            t1=time.time()
            func(*args, **kw)
            t2=time.time()
            cost_time = t2-t1
            print("{}-{}花費時間：{}秒".format(mode, type,cost_time))
        return deco
    return wrapper
複製程式碼

第一步，先來看看單執行緒的

@timer("【單執行緒】")
def single_thread(func, type=""):
    for i in range(10):
              func()

# 單執行緒
single_thread(count, type="CPU計算密集型")
single_thread(io_disk, type="磁碟IO密集型")
single_thread(io_request,type="網路IO密集型")
single_thread(io_simulation,type="模擬IO密集型")
複製程式碼

看看結果

【單執行緒】-CPU計算密集型花費時間：83.42633867263794秒
【單執行緒】-磁碟IO密集型花費時間：15.641993284225464秒
【單執行緒】-網路IO密集型花費時間：1.1397218704223633秒
【單執行緒】-模擬IO密集型花費時間：20.020972728729248秒
複製程式碼

第二步，再來看看多執行緒的

@timer("【多執行緒】")
def multi_thread(func, type=""):
    thread_list = []
    for i in range(10):
        t=Thread(target=func, args=())
        thread_list.append(t)
        t.start()
    e = len(thread_list)

    while True:
        for th in thread_list:
            if not th.is_alive():
                e -= 1
        if e <= 0:
            break

# 多執行緒
multi_thread(count, type="CPU計算密集型")
multi_thread(io_disk, type="磁碟IO密集型")
multi_thread(io_request, type="網路IO密集型")
multi_thread(io_simulation, type="模擬IO密集型")
複製程式碼

看看結果

【多執行緒】-CPU計算密集型花費時間：93.82986998558044秒
【多執行緒】-磁碟IO密集型花費時間：13.270896911621094秒
【多執行緒】-網路IO密集型花費時間：0.1828296184539795秒
【多執行緒】-模擬IO密集型花費時間：2.0288875102996826秒
複製程式碼

第三步，最後來看看多程式

@timer("【多程式】")
def multi_process(func, type=""):
    process_list = []
    for x in range(10):
        p = Process(target=func, args=())
        process_list.append(p)
        p.start()
    e = process_list.__len__()

    while True:
        for pr in process_list:
            if not pr.is_alive():
                e -= 1
        if e <= 0:
            break

# 多程式
multi_process(count, type="CPU計算密集型")
multi_process(io_disk, type="磁碟IO密集型")
multi_process(io_request, type="網路IO密集型")
multi_process(io_simulation, type="模擬IO密集型")
複製程式碼

看看結果

【多程式】-CPU計算密集型花費時間：9.082211017608643秒
【多程式】-磁碟IO密集型花費時間：1.287339448928833秒
【多程式】-網路IO密集型花費時間：0.13074755668640137秒
【多程式】-模擬IO密集型花費時間：2.0076842308044434秒
複製程式碼

. 效能對比成果總結

將結果彙總一下，製成表格。

我們來分析下這個表格。

首先是CPU密集型，多執行緒以對比單執行緒，不僅沒有優勢，顯然還由於要不斷的加鎖釋放GIL全域性鎖，切換執行緒而耗費大量時間，效率低下，而多程式，由於是多個CPU同時進行計算工作，相當於十個人做一個人的作業，顯然效率是成倍增長的。

然後是IO密集型，IO密集型可以是磁碟IO，網路IO，資料庫IO等，都屬於同一類，計算量很小，主要是IO等待時間的浪費。通過觀察，可以發現，我們磁碟IO，網路IO的資料，多執行緒對比單執行緒也沒體現出很大的優勢來。這是由於我們程式的的IO任務不夠繁重，所以優勢不夠明顯。

所以我還加了一個「模擬IO密集型」，用sleep來模擬IO等待時間，就是為了體現出多執行緒的優勢，也能讓大家更加直觀的理解多執行緒的工作過程。單執行緒需要每個執行緒都要sleep(2)，10個執行緒就是20s，而多執行緒，在sleep(2)的時候，會切換到其他執行緒，使得10個執行緒同時sleep(2)，最終10個執行緒也就只有2s.

可以得出以下幾點結論

• 單執行緒總是最慢的，多程式總是最快的。
• 多執行緒適合在IO密集場景下使用，譬如爬蟲，網站開發等
• 多程式適合在對CPU計算運算要求較高的場景下使用，譬如大資料分析，機器學習等
• 多程式雖然總是最快的，但是不一定是最優的選擇，因為它需要CPU資源支援下才能體現優勢

                                  

                                                關注公眾號，獲取最新文章