協(xié)程，又稱微線程，纖程。英文名 Coroutine。

協(xié)程是 Python 中另外一種實現(xiàn)多任務的方式，只不過比線程更小，占用更小執(zhí)行單元（理解為需要的資源）。

為啥說它是一個執(zhí)行單元，因為它自帶 CPU 上下文。這樣只要在合適的時機， 我們可以把一個協(xié)程 切換到另一個協(xié)程。 只要這個過程中保存或恢復 CPU上下文那么程序還是可以運行的。

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

協(xié)程和線程差異

在實現(xiàn)多任務時, 線程切換從系統(tǒng)層面遠不止保存和恢復 CPU上下文這么簡單。

操作系統(tǒng)為了程序運行的高效性每個線程都有自己緩存 Cache 等等數(shù)據(jù)，操作系統(tǒng)還會幫你做這些數(shù)據(jù)的恢復操作，所以線程的切換非常耗性能。

但是協(xié)程的切換只是單純的操作 CPU 的上下文，所以一秒鐘切換個上百萬次系統(tǒng)都抗得住。

之前我們講過 yield 關鍵字，現(xiàn)在就用它來實現(xiàn)多任務。

例子：

import time

def task_1():
  while True:
    print("--1--")
    time.sleep(0.5)
    yield

def task_2():
  while True:
    print("--2--")
    time.sleep(0.5)
    yield

def main():
  t1 = task_1()
  t2 = task_2()
  while True:
    next(t1)
    next(t2)

if __name__ == "__main__":
  main()

運行過程：

先讓 t1 運行一會，當 t1 遇到 yield 的時候，再返回到 main() 循環(huán)的地方，然后執(zhí)行 t2 ， 當它遇到 yield 的時候，再次切換到 t1 中，這樣 t1 和 t2 就交替運行，最終實現(xiàn)了多任務，協(xié)程。

運行結果：

greenlet

為了更好使用協(xié)程來完成多任務，Python 中的 greenlet 模塊對其封裝，從而使得切換任務變的更加簡單。

首先你要安裝一下 greenlet 模塊。

pip3 install greenlet

from greenlet import greenlet
import time

def test1():
  while True:
    print("---A--")
    gr2.switch()
    time.sleep(0.5)

def test2():
  while True:
    print("---B--")
    gr1.switch()
    time.sleep(0.5)

gr1 = greenlet(test1)
gr2 = greenlet(test2)

# 切換到gr1中運行
gr1.switch()

運行結果：

和我們之前用 yield 實現(xiàn)的效果基本一樣，greenlet 其實是對 yield 進行了簡單的封裝。

greenlet 實現(xiàn)多任務要比 yield 更簡單，但是我們以后還是不用它。

上面例子中的延時是0.5秒，如果延遲是100秒，那么程序就會卡住100秒，就算有其他需要執(zhí)行的任務，系統(tǒng)也不會切換過去，這100秒的時間是無法利用的。

這個問題下面來解決。

gevent

greenlet 已經實現(xiàn)了協(xié)程，但是還是得進行人工切換，是不是覺得太麻煩了。

Python 還有一個比 greenlet 更強大的并且能夠自動切換任務的模塊 gevent。

gevent 是對 greenlet 的再次封裝。

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

由于 IO 操作非常耗時，經常使程序處于等待狀態(tài)，有了gevent 為我們自動切換協(xié)程，就保證總有 greenlet 在運行，而不是等待 IO。

首先還是得先安裝 gevent。

pip3 install gevent

例子：

import gevent

def f(n):
  for i in range(n):
    print(gevent.getcurrent(), i)

g1 = gevent.spawn(f, 3)
g2 = gevent.spawn(f, 3)
g3 = gevent.spawn(f, 3)
g1.join()
g2.join()
g3.join()

運行結果:

<Greenlet at 0x35aae40: f(3)> 0
<Greenlet at 0x35aae40: f(3)> 1
<Greenlet at 0x35aae40: f(3)> 2
<Greenlet at 0x374a780: f(3)> 0
<Greenlet at 0x374a780: f(3)> 1
<Greenlet at 0x374a780: f(3)> 2
<Greenlet at 0x374a810: f(3)> 0
<Greenlet at 0x374a810: f(3)> 1
<Greenlet at 0x374a810: f(3)> 2

可以看到，3個 greenlet 是依次運行而不是交替運行。

這還無法判斷 gevent 是否實現(xiàn)了多任務的效果，最好的判斷情況是在運行結果中 0 1 2 不按順序出現(xiàn)。

在 gevent 的概念中，我們提到 gevent 在遇到延時的時候會自動切換任務。

那么，我們先給上面的例子添加延時，再看效果。

import gevent
import time

def f(n):
  for i in range(n):
    print(gevent.getcurrent(), i)
    time.sleep(0.5)

g1 = gevent.spawn(f, 3)
g2 = gevent.spawn(f, 3)
g3 = gevent.spawn(f, 3)
g1.join()
g2.join()
g3.join()

運行結果：

<Greenlet at 0x36aae40: f(3)> 0
<Greenlet at 0x36aae40: f(3)> 1
<Greenlet at 0x36aae40: f(3)> 2
<Greenlet at 0x384a780: f(3)> 0
<Greenlet at 0x384a780: f(3)> 1
<Greenlet at 0x384a780: f(3)> 2
<Greenlet at 0x384a810: f(3)> 0
<Greenlet at 0x384a810: f(3)> 1
<Greenlet at 0x384a810: f(3)> 2

在添加了延時之后，運行結果并沒有改變。

其實，gevent 要的不是 time.sleep() 的延時，而是 gevent.sleep() 的延時。

import gevent

def f(n):
  for i in range(n):
    print(gevent.getcurrent(), i)
    gevent.sleep(0.5)

g1 = gevent.spawn(f, 3)
g2 = gevent.spawn(f, 3)
g3 = gevent.spawn(f, 3)
g1.join()
g2.join()
g3.join()

join 還有一種更簡單的寫法。

import time
import gevent

def f(n):
  for i in range(n):
    print(gevent.getcurrent(), i)
    gevent.sleep(0.5)

gevent.joinall([
  gevent.spawn(f, 3),
  gevent.spawn(f, 3),
  gevent.spawn(f, 3)
])

一般都是后面的這種寫法。

運行結果:

<Greenlet at 0x2e5ae40: f(3)> 0
<Greenlet at 0x2ffa780: f(3)> 0
<Greenlet at 0x2ffa810: f(3)> 0
<Greenlet at 0x2e5ae40: f(3)> 1
<Greenlet at 0x2ffa780: f(3)> 1
<Greenlet at 0x2ffa810: f(3)> 1
<Greenlet at 0x2e5ae40: f(3)> 2
<Greenlet at 0x2ffa780: f(3)> 2
<Greenlet at 0x2ffa810: f(3)> 2

這下終于實現(xiàn)多任務的效果了, gevent 在遇到延時的時候，就自動切換到其他任務。

這里是將 time 中的 sleep 換成了 gevent 中的 sleep。

那如果有網絡程序，網絡程序中也有許多堵塞，比如 connect， recv，accept，需要不需要換成 gevent 中的對應方法。

理論上來說，是要換的。如果想用 gevent，那么就要把所有的延時操作，堵塞這一類的函數(shù)，統(tǒng)統(tǒng)換成 gevent 中的對應方法。

那有個問題，萬一我的代碼已經寫了10萬行了，這換起來怎么破......

有什么辦法不需要手動修改么，有，打個補丁即可。

import time
import gevent
from gevent import monkey

# 有耗時操作時需要
# 將程序中用到的耗時操作的代碼，換為gevent中自己實現(xiàn)的模塊
monkey.patch_all() 

def f(n):
  for i in range(n):
    print(gevent.getcurrent(), i)
    time.sleep(0.5)

g1 = gevent.spawn(f, 3)
g2 = gevent.spawn(f, 3)
g3 = gevent.spawn(f, 3)
g1.join()
g2.join()
g3.join()

monkey.patch_all() 會自動去檢查代碼，將所有會產生延時堵塞的方法，都自動換成 gevent 中的方法。

運行結果：

<Greenlet at 0x3dd91e0: f(3)> 0
<Greenlet at 0x3dd9810: f(3)> 0
<Greenlet at 0x3dd99c0: f(3)> 0
<Greenlet at 0x3dd91e0: f(3)> 1
<Greenlet at 0x3dd9810: f(3)> 1
<Greenlet at 0x3dd99c0: f(3)> 1
<Greenlet at 0x3dd91e0: f(3)> 2
<Greenlet at 0x3dd9810: f(3)> 2
<Greenlet at 0x3dd99c0: f(3)> 2

總結：

通過利用延時的時間去做其他任務，把時間都利用起來，這就是協(xié)程最大的意義。

到此這篇關于協(xié)程Python 中實現(xiàn)多任務耗資源最小的方式的文章就介紹到這了,更多相關Python多任務耗資源最小方式內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

最新評論