一、協(xié)程定義和作用

協(xié)程（coroutine），又稱為微線程，纖程。(協(xié)程是一種用戶態(tài)的輕量級線程)

作用：在執(zhí)行 A 函數(shù)的時候，可以隨時中斷，去執(zhí)行 B 函數(shù)，然后中斷繼續(xù)執(zhí)行 A 函數(shù) （可以自動切換），單著一過程并不是函數(shù)調(diào)用（沒有調(diào)用語句），過程很像多線程，然而協(xié) 程只有一個線程在執(zhí)行

1、使用協(xié)程的優(yōu)點

由于自身帶有上下文和棧，無需線程上下文切換的開銷,屬于程序級別的切換，操作系統(tǒng) 完全感知不到，因而更加輕量級；

無需原子操作的鎖定及同步的開銷；

方便切換控制流，簡化編程模型

單線程內(nèi)就可以實現(xiàn)并發(fā)的效果，最大限度地利用 cpu，且可擴展性高，成本低（注：一 個 CPU 支持上萬的協(xié)程都不是問題。所以很適合用于高并發(fā)處理）

2、使用協(xié)程的缺點

無法利用多核資源：協(xié)程的本質(zhì)是個單線程,它不能同時將 單個 CPU 的多個核用上,協(xié) 程需要和進程配合才能運行在多 CPU 上.當(dāng)然我們?nèi)粘Ｋ帉懙慕^大部分應(yīng)用都沒有這個必 要，除非是 cpu 密集型應(yīng)用。

進行阻塞（Blocking）操作（如 IO 時）會阻塞掉整個程序

# 協(xié)程的基本使用，  實現(xiàn)兩個任務(wù)的切換         yield  和 next 來回切換
def func1():
    for i in range(11):
        print(f"一班打印第{i}次數(shù)據(jù)")
        yield
def func2():
    g = func1()
    next(g)
    for i in range(10):
        print(f"二班打印第{i}次數(shù)據(jù)")
        next(g)
if __name__ == "__main__":
    func2()

二、Greenlet 的使用

單線程內(nèi)有多個任務(wù)，用greenlet實現(xiàn)任務(wù)的切換 greenlet 和 switch 組合

from greenlet import greenlet
# pip install greenlet
def gf(name):
    print(f'{name}:我想王者?。?)
    g2.switch('zf')
    print(f'{name}:我想吃大餐?。。?)
    g2.switch()
def bf(name):
    print(f'{name}:一塊去完?。。?)
    g1.switch()
    print(f'{name}:一起去吃?。?)
if __name__ == "__main__":
    g1 = greenlet(gf)
    g2 = greenlet(bf)
    # 切換任務(wù)
    g1.switch('dc')   # 只需要第一次上傳

三、Gevent的使用

Gevent 是一個第三方庫，可以輕松通過 gevent 實現(xiàn)并發(fā)同步或異步編程，在 gevent 中用到的主要模式是 Greenlet，它是以 C 擴展模塊形式接入 Python 的輕量級協(xié)程。

Greenlet 全部運行在主程序操作系統(tǒng)進程的內(nèi)部，但他們被協(xié)作式地調(diào)度。

from gevent import monkey; # 為了能識別time模塊的io
monkey.patch_all()  #必須放到被打補丁者的前面，如 time，socket 模塊之前
import gevent
# pip install gevent
from time import time,sleep
def gf(name):
    print(f'{name}:我想打王者??！')
    # gevent.sleep(2)
    sleep(2)
    print(f'{name}:我想吃大餐?。。?)
def bf(name):
    print(f'{name}:一起打?。?！')
    # gevent.sleep(2)
    sleep(2)
    print(f'{name}:一快去吃?。?)
if __name__ == "__main__":
    start = time()
    # 創(chuàng)建協(xié)程對象
    g1 = gevent.spawn(gf,'貂蟬')
    g2 = gevent.spawn(bf,'呂布')
    # 開啟任務(wù)
    g1.join()
    g2.join()
    end = time()
    print(end-start)

注意：上例 gevent.sleep(2)模擬的是 gevent 可以識別的 io 阻塞; 而 time.sleep(2)或其他的阻塞,gevent 是不能直接識別的需要用下面一行代碼,打補丁,就 可以識別了

四、async io 異步 IO

asyncio 是 python3.4 之后的協(xié)程模塊，是 python 實現(xiàn)并發(fā)重要的包，這個包使用事件 循環(huán)驅(qū)動實現(xiàn)并發(fā)。

事件循環(huán)是一種處理多并發(fā)量的有效方式，在維基百科中它被描述為「一種等待程序分配 事件或消息的編程架構(gòu)」，我們可以定義事件循環(huán)來簡化使用輪詢方法來監(jiān)控事件，通俗的說 法就是「當(dāng) A 發(fā)生時，執(zhí)行 B」。

• @asyncio.coroutine 協(xié)程裝飾器裝飾
• asyncio.sleep() 可以避免事件循環(huán)阻塞
• get_event_loop() 獲取事件循環(huán)
• Loop.run_until_complete() 監(jiān)聽事件循環(huán)
• gather() 封裝任務(wù)
• await 等于 yield from 就是在等待 task 結(jié)果

import asyncio
@asyncio.coroutine # python3.5 之前 官網(wǎng)說3.10將被移除
def func1():
    for i in range(5):
        print('一邊吃飯！！')
        yield from asyncio.sleep(0)
async def func2(): # python3.5以上
    for i in range(5):
        print('一邊打游戲！??！')
        await asyncio.sleep(0)
if __name__ == "__main__":
    g1 = func1()
    g2 = func2()
    # 獲取事件循環(huán)
    loop = asyncio.get_event_loop()
    # 監(jiān)聽事件循環(huán)
    loop.run_until_complete(asyncio.gather(g1,g2))
    # 關(guān)閉事件循環(huán)
    loop.close()

1、asyncio中的task的使用

import asyncio
import functools
async def compute(x,y):
    print(f'compute:{x}+{y}....')
    await asyncio.sleep(1)
    return x+y
async def print_sum(x,y):
    # 創(chuàng)建task
    task = asyncio.create_task(compute(x,y))        #python3.7以上寫法
    # task綁定回調(diào)函數(shù)
    task.add_done_callback(functools.partial(end,x,y))  #python3.7以上寫法
    # 釋放下cpu的使用
    await asyncio.sleep(0)
    print('--------------------print_num繼續(xù)執(zhí)行---------------------------')
    for i in range(1000000):
        if i%5000 ==0:
            print(i)
            await asyncio.sleep(0.1)
def end(n,m,t):
    print(f'{n}+{m}={t.result()}')
if __name__ == "__main__":
    loop = asyncio.get_event_loop()
    loop.run_until_complete(print_sum(1,2))
    loop.close()

五、總結(jié)

并行：指的是任務(wù)數(shù)小于等于 cpu 核數(shù)，即任務(wù)真的是一起執(zhí)行的

并發(fā)：指的是任務(wù)數(shù)多余 cpu 核數(shù)，通過操作系統(tǒng)的各種任務(wù)調(diào)度算法，實現(xiàn)用多個任 務(wù)“一起”執(zhí)行（實際上總有一些任務(wù)不在執(zhí)行，因為切換任務(wù)的速度相當(dāng)快，看上去一 起執(zhí)行而已）

進程與線程的區(qū)別：

1. 線程是程序執(zhí)行的最小單位，而進程是操作系統(tǒng)分配資源的最小單位；

2. 一個進程由一個或多個線程組成，線程是一個進程中代碼的不同執(zhí)行路線；

3. 進程之間相互獨立，但同一進程下的各個線程之間共享程序的內(nèi)存空間(包括代碼段、 數(shù)據(jù)集、堆等)及一些進程級的資源(如打開文件和信號)，某進程內(nèi)的線程在其它進程 不可見；

4. 調(diào)度和切換：線程上下文切換比進程上下文切換要快得多。

進程、線程和協(xié)程的特點

進程：擁有自己獨立的堆和棧，既不共享堆，也不共享棧，進程由操作系統(tǒng)調(diào)度；進程切換需要的資源很最大，效率很低

線程：擁有自己獨立的棧和共享的堆，共享堆，不共享棧，標(biāo)準(zhǔn)線程由操作系統(tǒng)調(diào)度；線 程切換需要的資源一般，效率一般（當(dāng)然了在不考慮 GIL 的情況下）

協(xié)程：擁有自己獨立的棧和共享的堆，共享堆，不共享棧，協(xié)程由程序員在協(xié)程的代碼里 顯示調(diào)度；協(xié)程切換任務(wù)資源很小，效率高

多進程、多線程根據(jù) cpu 核數(shù)不一樣可能是并行的，但是協(xié)程是在一個線程中 所以是并發(fā)

選擇技術(shù)考慮的因素：切換的效率、數(shù)據(jù)共享的問題、 數(shù)據(jù)安全、是否需要并發(fā)

總結(jié)

本篇文章就到這里了，希望能夠給你帶來幫助，也希望您能夠多多關(guān)注腳本之家的更多內(nèi)容！

最新評論