python中協程的詳解（附示例）

本篇文章給大家帶來的內容是關於python中協程的詳解（附示例），有一定的參考價值，有需要的朋友可以參考一下，希望對你有所幫助。

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

協程看上去也是子程序，但執行過程中，在子程序內部可中斷，然後轉而執行別的子程序，在適當的時候再返回來接著執行。

最大的優勢就是協程極高的執行效率。因為子程序切換不是線程切換，而是由程序自身控制，因此，沒有線程切換的開銷，和多線程比，線程數量越多，協程的性能優勢就越明顯。

第二大優勢就是不需要多線程的鎖機制，因為只有一個線程，也不存在同時寫變量衝突，在協程中控制共享資源不加鎖，只需要判斷狀態就好了，所以執行效率比多線程高很多。

因為協程是一個線程執行，那怎麼利用多核CPU呢？最簡單的方法是多進程+協程，既充分利用多核，又充分發揮協程的高效率，可獲得極高的性能。

yield實現協程

Python對協程的支持還非常有限，用在generator中的yield可以一定程度上實現協程。雖然支持不完全，但已經可以發揮相當大的威力了。

import threading

import time

def producer(c):

c.__next__()

n=0

while n<5:

n+=1

print('[生產者]產出第%s條數據' %(n))

res = c.send(n)

print('[返回]:%s' %(res))

def consumer():

r='sheenstar'

while True:

# 更新r值: r = 'This is ok!', c.__next__()

# n= yield r --> c.send(n) --> n更新

n = yield r

if not n:

break

print('[消費者]正在調用第%s條數據' %(n))

time.sleep(1)

r = 'This is ok!'

if __name__=='__main__':

print(threading.current_thread())

print(threading.active_count()) #查看當前進行的線程

c = consumer()

producer(c) #函數中有yield， 返回值為生成器;

print(threading.active_count()) #1

gevent庫實現協程

Python通過yield提供了對協程的基本支持，但是不完全。而第三方的gevent為Python提供了比較完善的協程支持。

gevent是第三方庫，通過greenlet實現協程，其基本思想是：

當一個greenlet遇到IO操作時，比如訪問網絡，就自動切換到其他的greenlet，等到IO操作完成，再在適當的時候切換回來繼續執行。由於IO操作非常耗時，經常使程序處於等待狀態，有了gevent為我們自動切換協程，就保證總有greenlet在運行，而不是等待IO。

由於切換是在IO操作時自動完成，所以gevent需要修改Python自帶的一些標準庫，這一過程在啟動時通過monkey patch完成。

假設多協程執行的任務， 沒有IO操作或者等待， 那麼協程間是依次運行， 而不是交替運行;

假設多協程執行的任務， IO操作或者等待， 那麼協程間是交替運行;

#沒有等待

import gevent

from gevent import monkey

monkey.patch_all()

def job(n):

for i in range(n):

print(gevent.getcurrent(),i)

def mian():

g1 = gevent.spawn(job,1)

g2 = gevent.spawn(job,2)

g3 = gevent.spawn(job,3)

gevent.joinall([g1,g2,g3])

print('協程執行任務結束...')

if __name__=="__main__":

mian()

"""

#有等待

import time

from gevent import monkey

monkey.patch_all()

import gevent

def job(n):

for i in range(n):

print(gevent.getcurrent(), i)

time.sleep(1)

def main1():

# 創建三個協程， 並讓該協程執行job任務

g1 = gevent.spawn(job, 2)

g2 = gevent.spawn(job, 3)

g3 = gevent.spawn(job, 2)

# 等待所有的協程執行結束， 再執行主程序；

gevent.joinall([g1, g2, g3])

print("任務執行結束.....")

main1()

協程與線程

做一個關於協程和線程花費時間的對比實驗，不具有參考性 。

import time

import gevent #導入協程

from gevent import monkey

from urllib.request import urlopen #連接網絡

from mytimeit import timeit #導入計算時間的裝飾器

from concurrent.futures import ThreadPoolExecutor #導入線程池

def get_len_url(url):

with urlopen(url) as u_conn:

data = u_conn.read()

# print('%s該網頁共%s字節' %(url,len(data)))

urls = ['http://httpbin.org', 'http://example.com/']*100

@timeit

def coroutineall():

gevents = [gevent.spawn(get_len_url,url) for url in urls]

gevent.joinall(gevents)

@timeit

def threadall():

with ThreadPoolExecutor(max_workers=100) as thpool:

thpool.map(get_len_url,urls)

if __name__=="__main__":

coroutineall()

threadall()

以上就是python中協程的詳解（附示例）的詳細內容，更多請關注其它相關文章！

更多技巧請《轉發 + 關注》哦！