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()