python協程原理

❶ python協程gevent怎麼用

在學習gevent之前，你肯定要知道你學的這個東西是什麼。

官方描述gevent

gevent is a coroutine-based Python networking library that uses greenlet to provide a high-level synchronous API on top of the libev event loop.

翻譯：gevent是一個基於協程的Python網路庫。我們先理解這句，也是這次學習的重點——協程。

wiki描述協程

與子常式一樣，協程也是一種程序組件。相對子常式而言，協程更為一般和靈活，但在實踐中使用沒有子常式那樣廣泛。子常式的起始處是惟一的入口點，一旦退出即完成了子常式的執行，子常式的一個實例只會返回一次；協程可以通過yield來調用其它協程。通過yield方式轉移執行權的協程之間不是調用者與被調用者的關系，而是彼此對稱、平等的。協程允許多個入口點，可以在指定位置掛起和恢復執行。

沒看懂？沒關系，我也沒看懂，不過算是有點線索：子常式。

子常式

過程有兩種，一種叫子常式（Subroutine），通常叫Sub；另一種叫函數（Function）。底層實現機制是一樣的，區別在於，Sub只執行操作，沒有返回值；Function不但執行操作，並且有返回值。用過VB的應該會比較清楚這點。（原諒我用了網路）說到底子常式就是過程，我們一般叫它函數。

說到函數，我就想吐槽了，不明白為什麼要叫函數。很多時候我們寫一個函數是為了封裝、模塊化某個功能，它是一個功能、或者說是一個過程。因為它包含的是類似於流程圖那樣的具體邏輯，先怎樣做，然後怎樣做；如果遇到A情況則怎樣，如果遇到B情況又怎樣。個人覺得還是叫過程比較好，叫做函數就讓人很糾結了，難道因為回歸到底層還是計算問題，出於數學的角度把它稱為函數？這個略坑啊！為了符合大家的口味，我還是稱之為函數好了（其實我也習慣叫函數了%>_

講到函數，我們就往底層深入一點，看看下面的代碼：

Python

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

def a():

print "a start"

b()

print "a end"

def b():

print "b start"

c()

print "b end"

def c():

print "c start"

print "c end"

if __name__ == "__main__":

a()

a start

b start

c start

c end

b end

a end

對於這樣的結果大家肯定不會意外的。每當函數被調用，就會在棧中開辟一個棧空間，調用結束後再回收該空間。

假設一個這樣的場景：有個講台，每個人都可以上去發表言論，但是每次講台只能站一個人。現在a在上面演講，當他說到「大家好！」的時候，b有個緊急通知要告訴大家，所以a就先下來讓b講完通知，然後a再上講台繼續演講。如果用函數的思想模擬這個問題，堆棧示意圖是這樣的：

那什麼東西有這樣的能力呢？我們很快就可以想到進程、線程，但是你真的想使用進程、線程如此重量級的東西在這么簡單的程序上嗎？野蠻的搶占式機制和笨重的上下文切換！

還有一種程序組件，那就是協程。它能保留上一次調用時的狀態，每次重新進入該過程的時候，就相當於回到上一次離開時所處邏輯流的位置。協程的起始處是第一個入口點，在協程里，返回點之後是接下來的入口點。協程的生命期完全由他們的使用的需要決定。每個協程在用yield命令向另一個協程交出控制時都盡可能做了更多的工作，放棄控制使得另一個協程從這個協程停止的地方開始，接下來的每次協程被調用時，都是從協程返回（或yield）的位置接著執行。

從上面這些你就可以知道其實協程是模擬了多線程（或多進程）的操作，多線程在切換的時候都會有一個上下文切換，在退出的時候將現場保存起來，等到下一次進入的時候從保存的現場開始，繼續執行。

看下協程是怎樣實現的：

Python

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

import random

from time import sleep

from greenlet import greenlet

from Queue import Queue

queue = Queue(1)

@greenlet

def procer():

chars = ['a', 'b', 'c', 'd', 'e']

global queue

while True:

char = random.choice(chars)

queue.put(char)

print "Proced: ", char

sleep(1)

consumer.switch()

@greenlet

def consumer():

global queue

while True:

char = queue.get()

print "Consumed: ", char

sleep(1)

procer.switch()

if __name__ == "__main__":

procer.run()

consumer.run()

應用場景

我們一直都在大談協程是什麼樣一個東西，卻從沒有提起協程用來幹嘛，這個其實大家分析一下就能夠知道。從上面的生產者——消費者問題應該能看出，它分別有兩個任務，假設交給兩個人去執行，但每次只能允許一個人行動。當緩沖區滿的時候，生產者是出於等待狀態的，這個時候可以將執行任務的權利轉交給消費者，當緩沖區空得時候，消費者是出於等待狀態的，這個時候可以將執行任務的權利轉交給生產者，是不是很容易聯想到多任務切換？然後想到線程？最後想到高並發？

但同學們又會問，既然有了線程為什麼還要協程呢？因為線程是系統級別的，在做切換的時候消耗是特別大的，具體為什麼這么大等我研究好了再告訴你；同時線程的切換是由CPU決定的，可能你剛好執行到一個地方的時候就要被迫終止，這個時候你需要用各種措施來保證你的數據不出錯，所以線程對於數據安全的操作是比較復雜的。而協程是用戶級別的切換，且切換是由自己控制，不受外力終止。

總結

協程其實模擬了人類活動的一種過程。例如：你准備先寫文檔，然後修復bug。這時候接到電話說這個bug很嚴重，必須立即修復（可以看作CPU通知）。於是你暫停寫文檔，開始去填坑，終於你把坑填完了，你回來寫文檔，這個時候你肯定是接著之前寫的文檔繼續，難道你要把之前寫的給刪了，重新寫？這就是協程。那如果是子常式呢？那你就必須重新寫了，因為退出之後，棧幀就會被彈出銷毀，再次調用就是開辟新的棧空間了。

總結：協程就是用戶態下的線程，是人們在有了進程、線程之後仍覺得效率不夠，而追求的又一種高並發解決方案。為什麼說是用戶態，是因為操作系統並不知道它的存在，它是由程序員自己控制、互相協作的讓出控制權而不是像進程、線程那樣由操作系統調度決定是否讓出控制權。

❷ 簡述python進程，線程和協程的區別及應用場景

協程多與線程進行比較
1) 一個線程可以多個協程，一個進程也可以單獨擁有多個協程，這樣python中則能使用多核CPU。
2) 線程進程都是同步機制，而協程則是非同步
3) 協程能保留上一次調用時的狀態，每次過程重入時，就相當於進入上一次調用的狀態

❸ 一篇文章帶你深度解析Python線程和進程

使用Python中的線程模塊，能夠同時運行程序的不同部分，並簡化設計。如果你已經入門Python，並且想用線程來提升程序運行速度的話，希望這篇教程會對你有所幫助。

線程與進程

什麼是進程

進程是系統進行資源分配和調度的一個獨立單位 進程是具有一定獨立功能的程序關於某個數據集合上的一次運行活動,進程是系統進行資源分配和調度的一個獨立單位。每個進程都有自己的獨立內存空間，不同進程通過進程間通信來通信。由於進程比較重量，占據獨立的內存，所以上下文進程間的切換開銷（棧、寄存器、虛擬內存、文件句柄等）比較大，但相對比較穩定安全。

什麼是線程

CPU調度和分派的基本單位 線程是進程的一個實體，是CPU調度和分派的基本單位,它是比進程更小的能獨立運行的基本單位.線程自己基本上不擁有系統資源,只擁有一點在運行中必不可少的資源(如程序計數器,一組寄存器和棧),但是它可與同屬一個進程的其他的線程共享進程所擁有的全部資源。線程間通信主要通過共享內存，上下文切換很快，資源開銷較少，但相比進程不夠穩定容易丟失數據。

進程與線程的關系圖

線程與進程的區別：

進程

現實生活中，有很多的場景中的事情是同時進行的，比如開車的時候 手和腳共同來駕駛 汽車 ，比如唱歌跳舞也是同時進行的，再比如邊吃飯邊打電話；試想如果我們吃飯的時候有一個領導來電，我們肯定是立刻就接聽了。但是如果你吃完飯再接聽或者回電話，很可能會被開除。

注意：

多任務的概念

什麼叫 多任務 呢？簡單地說，就是操作系統可以同時運行多個任務。打個比方，你一邊在用瀏覽器上網，一邊在聽MP3，一邊在用Word趕作業，這就是多任務，至少同時有3個任務正在運行。還有很多任務悄悄地在後台同時運行著，只是桌面上沒有顯示而已。

現在，多核CPU已經非常普及了，但是，即使過去的單核CPU，也可以執行多任務。由於CPU執行代碼都是順序執行的，那麼，單核CPU是怎麼執行多任務的呢？

答案就是操作系統輪流讓各個任務交替執行，任務1執行0.01秒，切換到任務2，任務2執行0.01秒，再切換到任務3，執行0.01秒，這樣反復執行下去。表面上看，每個任務都是交替執行的，但是，由於CPU的執行速度實在是太快了，我們感覺就像所有任務都在同時執行一樣。

真正的並行執行多任務只能在多核CPU上實現，但是，由於任務數量遠遠多於CPU的核心數量，所以，操作系統也會自動把很多任務輪流調度到每個核心上執行。 其實就是CPU執行速度太快啦！以至於我們感受不到在輪流調度。

並行與並發

並行（Parallelism）

並行：指兩個或兩個以上事件（或線程）在同一時刻發生，是真正意義上的不同事件或線程在同一時刻，在不同CPU資源呢上（多核），同時執行。

特點

並發（Concurrency）

指一個物理CPU(也可以多個物理CPU) 在若幹道程序（或線程）之間多路復用，並發性是對有限物理資源強制行使多用戶共享以提高效率。

特點

multiprocess.Process模塊

process模塊是一個創建進程的模塊，藉助這個模塊，就可以完成進程的創建。

語法：Process([group [, target [, name [, args [, kwargs]]]]])

由該類實例化得到的對象，表示一個子進程中的任務（尚未啟動）。

注意：1. 必須使用關鍵字方式來指定參數；2. args指定的為傳給target函數的位置參數，是一個元祖形式，必須有逗號。

參數介紹：

group：參數未使用，默認值為None。

target：表示調用對象，即子進程要執行的任務。

args：表示調用的位置參數元祖。

kwargs：表示調用對象的字典。如kwargs = {'name':Jack, 'age':18}。

name：子進程名稱。

代碼：

除了上面這些開啟進程的方法之外，還有一種以繼承Process的方式開啟進程的方式：

通過上面的研究，我們千方百計實現了程序的非同步，讓多個任務可以同時在幾個進程中並發處理，他們之間的運行沒有順序，一旦開啟也不受我們控制。盡管並發編程讓我們能更加充分的利用IO資源，但是也給我們帶來了新的問題。

當多個進程使用同一份數據資源的時候，就會引發數據安全或順序混亂問題，我們可以考慮加鎖，我們以模擬搶票為例，來看看數據安全的重要性。

加鎖可以保證多個進程修改同一塊數據時，同一時間只能有一個任務可以進行修改，即串列的修改。加鎖犧牲了速度，但是卻保證了數據的安全。

因此我們最好找尋一種解決方案能夠兼顧：1、效率高（多個進程共享一塊內存的數據）2、幫我們處理好鎖問題。

mutiprocessing模塊為我們提供的基於消息的IPC通信機制：隊列和管道。隊列和管道都是將數據存放於內存中 隊列又是基於（管道+鎖）實現的，可以讓我們從復雜的鎖問題中解脫出來， 我們應該盡量避免使用共享數據，盡可能使用消息傳遞和隊列，避免處理復雜的同步和鎖問題，而且在進程數目增多時，往往可以獲得更好的可獲展性（ 後續擴展該內容 ）。

線程

Python的threading模塊

Python 供了幾個用於多線程編程的模塊，包括 thread, threading 和 Queue 等。thread 和 threading 模塊允許程序員創建和管理線程。thread 模塊 供了基本的線程和鎖的支持，而 threading 供了更高級別，功能更強的線程管理的功能。Queue 模塊允許用戶創建一個可以用於多個線程之間 共享數據的隊列數據結構。

python創建和執行線程

創建線程代碼

1. 創建方法一:

2. 創建方法二:

進程和線程都是實現多任務的一種方式，例如：在同一台計算機上能同時運行多個QQ（進程),一個QQ可以打開多個聊天窗口（線程）。資源共享：進程不能共享資源，而線程共享所在進程的地址空間和其他資源，同時，線程有自己的棧和棧指針。所以在一個進程內的所有線程共享全局變數，但多線程對全局變數的更改會導致變數值得混亂。

代碼演示:

得到的結果是：

首先需要明確的一點是GIL並不是Python的特性，它是在實現Python解析器(CPython)時所引入的一個概念。就好比C++是一套語言（語法）標准，但是可以用不同的編譯器來編譯成可執行代碼。同樣一段代碼可以通過CPython，PyPy，Psyco等不同的Python執行環境來執行（其中的JPython就沒有GIL）。

那麼CPython實現中的GIL又是什麼呢？GIL全稱Global Interpreter Lock為了避免誤導，我們還是來看一下官方給出的解釋：

主要意思為:

因此，解釋器實際上被一個全局解釋器鎖保護著，它確保任何時候都只有一個Python線程執行。在多線程環境中，Python 虛擬機按以下方式執行:

由於GIL的存在，Python的多線程不能稱之為嚴格的多線程。因為 多線程下每個線程在執行的過程中都需要先獲取GIL，保證同一時刻只有一個線程在運行。

由於GIL的存在，即使是多線程，事實上同一時刻只能保證一個線程在運行， 既然這樣多線程的運行效率不就和單線程一樣了嗎，那為什麼還要使用多線程呢？

由於以前的電腦基本都是單核CPU，多線程和單線程幾乎看不出差別，可是由於計算機的迅速發展，現在的電腦幾乎都是多核CPU了，最少也是兩個核心數的，這時差別就出來了：通過之前的案例我們已經知道，即使在多核CPU中，多線程同一時刻也只有一個線程在運行，這樣不僅不能利用多核CPU的優勢，反而由於每個線程在多個CPU上是交替執行的，導致在不同CPU上切換時造成資源的浪費，反而會更慢。即原因是一個進程只存在一把gil鎖，當在執行多個線程時，內部會爭搶gil鎖，這會造成當某一個線程沒有搶到鎖的時候會讓cpu等待，進而不能合理利用多核cpu資源。

但是在使用多線程抓取網頁內容時，遇到IO阻塞時，正在執行的線程會暫時釋放GIL鎖，這時其它線程會利用這個空隙時間，執行自己的代碼，因此多線程抓取比單線程抓取性能要好，所以我們還是要使用多線程的。

GIL對多線程Python程序的影響

程序的性能受到計算密集型(CPU)的程序限制和I/O密集型的程序限制影響,那什麼是計算密集型和I/O密集型程序呢?

計算密集型：要進行大量的數值計算，例如進行上億的數字計算、計算圓周率、對視頻進行高清解碼等等。這種計算密集型任務雖然也可以用多任務完成，但是花費的主要時間在任務切換的時間，此時CPU執行任務的效率比較低。

IO密集型：涉及到網路請求(time.sleep())、磁碟IO的任務都是IO密集型任務，這類任務的特點是CPU消耗很少，任務的大部分時間都在等待IO操作完成（因為IO的速度遠遠低於CPU和內存的速度）。對於IO密集型任務，任務越多，CPU效率越高，但也有一個限度。

當然為了避免GIL對我們程序產生影響，我們也可以使用，線程鎖。

Lock&RLock

常用的資源共享鎖機制：有Lock、RLock、Semphore、Condition等，簡單給大家分享下Lock和RLock。

Lock

特點就是執行速度慢，但是保證了數據的安全性

RLock

使用鎖代碼操作不當就會產生死鎖的情況。

什麼是死鎖

死鎖：當線程A持有獨占鎖a，並嘗試去獲取獨占鎖b的同時，線程B持有獨占鎖b，並嘗試獲取獨占鎖a的情況下，就會發生AB兩個線程由於互相持有對方需要的鎖，而發生的阻塞現象，我們稱為死鎖。即死鎖是指多個進程因競爭資源而造成的一種僵局，若無外力作用，這些進程都將無法向前推進。

所以，在系統設計、進程調度等方面注意如何不讓這四個必要條件成立，如何確定資源的合理分配演算法，避免進程永久占據系統資源。

死鎖代碼

python線程間通信

如果各個線程之間各干各的，確實不需要通信，這樣的代碼也十分的簡單。但這一般是不可能的，至少線程要和主線程進行通信，不然計算結果等內容無法取回。而實際情況中要復雜的多，多個線程間需要交換數據，才能得到正確的執行結果。

python中Queue是消息隊列，提供線程間通信機制，python3中重名為為queue，queue模塊塊下提供了幾個阻塞隊列，這些隊列主要用於實現線程通信。

在 queue 模塊下主要提供了三個類，分別代表三種隊列，它們的主要區別就在於進隊列、出隊列的不同。

簡單代碼演示

此時代碼會阻塞，因為queue中內容已滿，此時可以在第四個queue.put('蘋果')後面添加timeout，則成為 queue.put('蘋果'，timeout=1)如果等待1秒鍾仍然是滿的就會拋出異常，可以捕獲異常。

同理如果隊列是空的，無法獲取到內容默認也會阻塞，如果不阻塞可以使用queue.get_nowait()。

在掌握了 Queue 阻塞隊列的特性之後，在下面程序中就可以利用 Queue 來實現線程通信了。

下面演示一個生產者和一個消費者，當然都可以多個

使用queue模塊，可在線程間進行通信，並保證了線程安全。

協程

協程，又稱微線程，纖程。英文名Coroutine。

協程是python個中另外一種實現多任務的方式，只不過比線程更小佔用更小執行單元（理解為需要的資源）。為啥說它是一個執行單元，因為它自帶CPU上下文。這樣只要在合適的時機， 我們可以把一個協程 切換到另一個協程。只要這個過程中保存或恢復 CPU上下文那麼程序還是可以運行的。

通俗的理解：在一個線程中的某個函數，可以在任何地方保存當前函數的一些臨時變數等信息，然後切換到另外一個函數中執行，注意不是通過調用函數的方式做到的，並且切換的次數以及什麼時候再切換到原來的函數都由開發者自己確定。

在實現多任務時，線程切換從系統層面遠不止保存和恢復 CPU上下文這么簡單。操作系統為了程序運行的高效性每個線程都有自己緩存Cache等等數據，操作系統還會幫你做這些數據的恢復操作。所以線程的切換非常耗性能。但是協程的切換只是單純的操作CPU的上下文，所以一秒鍾切換個上百萬次系統都抗的住。

greenlet與gevent

為了更好使用協程來完成多任務，除了使用原生的yield完成模擬協程的工作，其實python還有的greenlet模塊和gevent模塊，使實現協程變的更加簡單高效。

greenlet雖說實現了協程，但需要我們手工切換，太麻煩了，gevent是比greenlet更強大的並且能夠自動切換任務的模塊。

其原理是當一個greenlet遇到IO(指的是input output 輸入輸出，比如網路、文件操作等)操作時，比如訪問網路，就自動切換到其他的greenlet，等到IO操作完成，再在適當的時候切換回來繼續執行。

模擬耗時操作：

如果有耗時操作也可以換成，gevent中自己實現的模塊，這時候就需要打補丁了。

使用協程完成一個簡單的二手房信息的爬蟲代碼吧！

以下文章來源於Python專欄 ，作者宋宋

文章鏈接：https://mp.weixin.qq.com/s/2r3_ipU3HjdA5VnqSHjUnQ

❹ 在python中線程和協程的區別是什麼

在python中線程和協程的區別：1、一個線程可以擁有多個協程，這樣在python中就能使用多核CPU；2、線程是同步機制，而協程是非同步；3、 協程能保留上一次調用時的狀態，每次過程重入時，就相當於進入上一次調用的狀態。

一、首先我們來了解一下線程和協程的概念

1、線程

線程是進程的一個實體,是CPU調度和分派的基本單位,它是比進程更小的能獨立運行的基本單位.線程自己基本上不擁有系統資源,只擁有一點在運行中必不可少的資源(如程序計數器,一組寄存器和棧),但是它可與同屬一個進程的其他的線程共享進程所擁有的全部資源。線程間通信主要通過共享內存，上下文切換很快，資源開銷較少，但相比進程不夠穩定容易丟失數據。

2、協程

協程是一種用戶態的輕量級線程，協程的調度完全由用戶控制。協程擁有自己的寄存器上下文和棧。協程調度切換時，將寄存器上下文和棧保存到其他地方，在切回來的時候，恢復先前保存的寄存器上下文和棧，直接操作棧則基本沒有內核切換的開銷，可以不加鎖的訪問全局變數，所以上下文的切換非常快。

二、協程與線程的比較

1) 一個線程可以擁有多個協程，一個進程也可以單獨擁有多個協程，這樣python中則能使用多核CPU。

2) 線程進程都是同步機制，而協程則是非同步。

3)協程能保留上一次調用時的狀態，每次過程重入時，就相當於進入上一次調用的狀態。

三、線程、協程在python中的使用

1、多線程一般是使用threading庫，完成一些IO密集型並發操作。多線程的優勢是切換快，資源消耗低，但一個線程掛掉則會影響到所有線程，所以不夠穩定。現實中使用線程池的場景會比較多，具體可參考《python線程池實現》。

2、協程一般是使用gevent庫，當然這個庫用起來比較麻煩，所以使用的並不是很多。相反，協程在tornado的運用就多得多了，使用協程讓tornado做到單線程非同步，據說還能解決C10K的問題。所以協程使用的地方最多的是在web應用上。

總結一下：

IO密集型一般使用多線程或者多進程，CPU密集型一般使用多進程，強調非阻塞非同步並發的一般都是使用協程，當然有時候也是需要多進程線程池結合的，或者是其他組合方式。

推薦課程：Python高級進階視頻教程

❺ 2020-08-20：GO語言中的協程與Python中的協程的區別

福哥答案2020-08-20：

1.golang的協程是基於gpm機制，是可以多核多線程的。Python的協程是eventloop模型（IO多空友路復用技術改虧喊）實現，協程是嚴格的 1:N 關系，也就是一個線程對應了多個協程。雖然可以實現非同步I/O，但是不能有效利用核野多核(GIL)。
2.golang用go func。python用import asyncio，async/await表達式。

評論

❻ python非同步協程跟多進程多線程哪個效率高

線程是操作系統能夠進行運算調度的最小單位。它被包含在進程之中，是進程中的實際運作單位。

一個程序的執行實例就是一個進程。每一個進程提供執行程序所需的所有資源。

PS：上面都是摘抄自網頁鏈接這里的，具體的可以看看這里，你的答案在圖片的最後一點。因為線程和進程是不能層面的定義，一個進程可以包括多個線程，所以沒有可比性~

❼ python協程（4）：asyncio

asyncio是官方提供的協程的類庫，從python3.4開始支持該模塊

async & awiat是python3.5中引入的關鍵字，使用async關鍵字可以將一個函數定義為協程函數，使用awiat關鍵字可以在遇到IO的時候掛起當前協程（也就是任務），去執行其他協程。
await + 可等待的對象（協程對象、Future對象、Task對象 -> IO等待）
注意：在python3.4中是通過asyncio裝飾器定義協程，在python3.8中已經移除了asyncio裝飾器。

事件循環，可以把他當做是一個while循環，這個while循環在周期性的運行並執行一些協程（任務），在特定條件下終止循環。
loop = asyncio.get_event_loop()：生成一個事件循環
loop.run_until_complete(任務)：將任務放到事件循環

Tasks用於並發調度協程，通過asyncio.create_task(協程對象)的方式創建Task對象，這樣可以讓協程加入事件循環中等待被調度執行。除了使用 asyncio.create_task() 函數以外，還可以用低層級的 loop.create_task() 或 ensure_future() 函數。不建議手動實例化 Task 對象。

本質上是將協程對象封裝成task對象，並將協程立即加入事件循環，同時追蹤協程的狀態。

注意：asyncio.create_task() 函數在 Python 3.7 中被加入。在 Python 3.7 之前，可以改用 asyncio.ensure_future() 函數。

下面結合async & awiat、事件循環和Task看一個示例
示例一：

*注意：python 3.7以後增加了asyncio.run（協程對象），效果等同於loop = asyncio.get_event_loop()，loop.run_until_complete(協程對象) *

示例二：

注意：asyncio.wait 源碼內部會對列表中的每個協程執行ensure_future從而封裝為Task對象，所以在和wait配合使用時task_list的值為[func(),func()] 也是可以的。

示例三：