Python併發編程之從性能角度來初探併發編程（一）

時間 2020-11-23

標籤 html python 程序員 web 數據庫編程網絡多線程併發 app 欄目 Python 简体版

原文原文鏈接

本文目錄

併發編程的基本概念html
單線程VS多線程VS多進程python
性能對比成果總結程序員

前言

做爲進階系列的一個分支「併發編程」，我以爲這是每一個程序員都應該會的。web

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

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

對於併發編程，Python的實現，總結了一下，大體有以下三種方法：網絡

多線程多線程
多進程併發
協程（生成器）app

在以後的章節裏，將陸陸續續地給你們介紹到這三個知識點。

. 併發編程的基本概念

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

串行：一我的在同一時間段只能幹一件事，譬如吃完飯才能看電視；
並行：一我的在同一時間段能夠幹多件事，譬如能夠邊吃飯邊看電視；

在Python中，多線程 和 協程 雖然是嚴格上來講是串行，但卻比通常的串行程序執行效率高得很。
通常的串行程序，在程序阻塞的時候，只能乾等着，不能去作其餘事。就好像，電視上播完正劇，進入廣告時間，咱們卻不能去趁廣告時間是吃個飯。對於程序來講，這樣作顯然是效率極低的，是不合理的。

固然，學完這個課程後，咱們就懂得，利用廣告時間去作其餘事，靈活安排時間。這也是咱們多線程和協程 要幫咱們要完成的事情，內部合理調度任務，使得程序效率最大化。

雖然 多線程 和 協程 已經至關智能了。但仍是不夠高效，最高效的應該是一心多用，邊看電視邊吃飯邊聊天。這就是咱們的 多進程才能作的事了。

爲了更幫助你們更加直觀的理解，在網上找到兩張圖，來生動形象的解釋了多線程和多進程的區別。（侵刪）

多線程，交替執行，另外一種意義上的串行。

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

. 單線程VS多線程VS多進程

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

接下來，讓咱們一塊兒用代碼來測試一下，單線程、多線程、多進程到底性能差多少呢？

首先，準備環境，個人實驗環境配置以下：

操做系統	CPU核數	內存(G)	硬盤
CentOS 7.2	24核	32	機械硬盤

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

裝飾器的運用

多線程的基本使用

多進程的基本使用

固然，看不懂也不要緊，主要最後的結論，能讓你們對單線程、多線程、多進程在實現效果上有個大致清晰的認識，達到這個效果，本文的使命也就完成了，等到最後，學完整個系列，不妨再回頭來理解也許會有更深入的理解。

下面咱們來看看，單線程，多線程和多進程，在運行中究竟孰強孰弱。

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

CPU計算密集型
磁盤IO密集型
網絡IO密集型
【模擬】IO密集型

爲何是這幾種場景，這和多線程 多進程的適用場景有關。結論裏，我再說明。

 1# CPU計算密集型
 2def count(x=1, y=1):
 3    # 使程序完成150萬計算
 4    c = 0
 5    while c < 500000:
 6        c += 1
 7        x += x
 8        y += y
 9
10
11# 磁盤讀寫IO密集型
12def io_disk():
13    with open("file.txt", "w") as f:
14        for x in range(5000000):
15            f.write("python-learning\n")
16
17
18# 網絡IO密集型
19header = {
20    'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3359.139 Safari/537.36'}
21url = "https://www.tieba.com/"
22
23def io_request():
24    try:
25        webPage = requests.get(url, headers=header)
26        html = webPage.text
27        return
28    except Exception as e:
29        return {"error": e}
30
31
32# 【模擬】IO密集型
33def io_simulation():
34    time.sleep(2)

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

爲了方便，使得代碼看起來，更加簡潔，我這裏先定義是一個簡單的時間計時器 的裝飾器。
若是你對裝飾器還不是很瞭解，也不要緊，你只要知道它是用於計算函數運行時間的東西就能夠了。

 1def timer(mode):
 2    def wrapper(func):
 3        def deco(*args, **kw):
 4            type = kw.setdefault('type', None)
 5            t1=time.time()
 6            func(*args, **kw)
 7            t2=time.time()
 8            cost_time = t2-t1
 9            print("{}-{}花費時間：{}秒".format(mode, type,cost_time))
10        return deco
11    return wrapper

第一步，先來看看單線程的

 1@timer("【單線程】")
 2def single_thread(func, type=""):
 3    for i in range(10):
 4              func()
 5
 6# 單線程
 7single_thread(count, type="CPU計算密集型")
 8single_thread(io_disk, type="磁盤IO密集型")
 9single_thread(io_request,type="網絡IO密集型")
10single_thread(io_simulation,type="模擬IO密集型")

看看結果

1【單線程】-CPU計算密集型花費時間：83.42633867263794秒
2【單線程】-磁盤IO密集型花費時間：15.641993284225464秒
3【單線程】-網絡IO密集型花費時間：1.1397218704223633秒
4【單線程】-模擬IO密集型花費時間：20.020972728729248秒

第二步，再來看看多線程的

 1@timer("【多線程】")
 2def multi_thread(func, type=""):
 3    thread_list = []
 4    for i in range(10):
 5        t=Thread(target=func, args=())
 6        thread_list.append(t)
 7        t.start()
 8    e = len(thread_list)
 9
10    while True:
11        for th in thread_list:
12            if not th.is_alive():
13                e -= 1
14        if e <= 0:
15            break
16
17# 多線程
18multi_thread(count, type="CPU計算密集型")
19multi_thread(io_disk, type="磁盤IO密集型")
20multi_thread(io_request, type="網絡IO密集型")
21multi_thread(io_simulation, type="模擬IO密集型")

看看結果

1【多線程】-CPU計算密集型花費時間：93.82986998558044秒
2【多線程】-磁盤IO密集型花費時間：13.270896911621094秒
3【多線程】-網絡IO密集型花費時間：0.1828296184539795秒
4【多線程】-模擬IO密集型花費時間：2.0288875102996826秒

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

 1@timer("【多進程】")
 2def multi_process(func, type=""):
 3    process_list = []
 4    for x in range(10):
 5        p = Process(target=func, args=())
 6        process_list.append(p)
 7        p.start()
 8    e = process_list.__len__()
 9
10    while True:
11        for pr in process_list:
12            if not pr.is_alive():
13                e -= 1
14        if e <= 0:
15            break
16
17# 多進程
18multi_process(count, type="CPU計算密集型")
19multi_process(io_disk, type="磁盤IO密集型")
20multi_process(io_request, type="網絡IO密集型")
21multi_process(io_simulation, type="模擬IO密集型")

看看結果

1【多進程】-CPU計算密集型花費時間：9.082211017608643秒
2【多進程】-磁盤IO密集型花費時間：1.287339448928833秒
3【多進程】-網絡IO密集型花費時間：0.13074755668640137秒
4【多進程】-模擬IO密集型花費時間：2.0076842308044434秒

. 性能對比成果總結

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

種類	CPU 計算密集型	磁盤 IO密集型	網絡 IO密集型	模擬 IO密集型
單線程	83.42	15.64	1.13	20.02
多線程	93.82	13.27	0.18	2.02
多進程	9.08	1.28	0.13	2.01

咱們來分析下這個表格。

首先是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.

能夠得出如下幾點結論