python——asyncio模塊實現協程、異步編程

我們都知道，現在的服務器開發對於IO調度的優先級控制權已經不再依靠系統，都希望采用協程的方式實現高效的並發任務，如js、lua等在異步協程方面都做的很強大。

Python在3.4版本也加入了協程的概念，並在3.5確定了基本完善的語法和實現方式。同時3.6也對其進行了如解除了await和yield在同一個函數體限制等相關的優化。

event_loop 事件循環：程序開啟一個無限的循環，程序員會把一些函數注冊到事件循環上。當滿足事件發生的時候，調用相應的協程函數。
coroutine 協程：協程對象，指一個使用async關鍵字定義的函數，它的調用不會立即執行函數，而是會返回一個協程對象。協程對象需要注冊到事件循環，由事件循環調用。
task 任務：一個協程對象就是一個原生可以掛起的函數，任務則是對協程進一步封裝，其中包含任務的各種狀態。
future： 代表將來執行或沒有執行的任務的結果。它和task上沒有本質的區別
async/await 關鍵字：python3.5 用於定義協程的關鍵字，async定義一個協程，await用於掛起阻塞的異步調用接口。

 

【一】創建協程

首先定義一個協程，在def前加入async聲明，就可以定義一個協程函數。

一個協程函數不能直接調用運行，只能把協程加入到事件循環loop中。asyncio.get_event_loop方法可以創建一個事件循環，然后使用run_until_complete將協程注冊到事件循環，並啟動事件循環。

例如：

 

import asyncio

async def fun():
    print('hello word')

loop = asyncio.get_event_loop()

loop.run_until_complete(fun())

 

 

 

【二】任務對象task

協程對象不能直接運行，在注冊事件循環的時候，其實是run_until_complete方法將協程包裝成為了一個任務（task）對象。所謂task對象是Future類的子類。保存了協程運行后的狀態，用於未來獲取協程的結果。

例如：

 

import asyncio

async def fun():
    print('hello word')
    return 'miao'

loop = asyncio.get_event_loop()
task = loop.create_task(fun())
print(task)
loop.run_until_complete(task)
print(task)

 

創建task后，task在加入事件循環之前是pending狀態，因為do_some_work中沒有耗時的阻塞操作，task很快就執行完畢了。后面打印的finished狀態。
asyncio.ensure_future 和 loop.create_task都可以創建一個task，run_until_complete的參數是一個futrue對象。當傳入一個協程，其內部會自動封裝成task，task是Future的子類。isinstance(task, asyncio.Future)將會輸出True。

 

【三】綁定回調

在task執行完畢的時候可以獲取執行的結果，回調的最后一個參數是future對象，通過該對象可以獲取協程返回值。如果回調需要多個參數，可以通過偏函數導入。

例如：

 

import asyncio

async def fun():
    print('hello word')
    return 'miao'


def callback(future):
    print('Callback: ', future.result())

loop = asyncio.get_event_loop()
task = loop.create_task(fun())
#print(task)
task.add_done_callback(callback)
loop.run_until_complete(task)
#print(task)

 

 

也可以使用ensure_future獲取返回值

例如：

 

import asyncio

async def fun():
    print('hello word')
    return 'miao'


#def callback(future):
    #print('Callback: ', future.result())

loop = asyncio.get_event_loop()
#task = loop.create_task(fun())
#task.add_done_callback(callback)
task = asyncio.ensure_future(fun())
loop.run_until_complete(task)

print('the fun() return is: {}'.format(task.result()))

 

 

【四】await阻塞

使用async可以定義協程對象，使用await可以針對耗時的操作進行掛起，就像生成器里的yield一樣，函數讓出控制權。協程遇到await，事件循環將會掛起該協程，執行別的協程，直到其他的協程也掛起或者執行完畢，再進行下一個協程的執行。
耗時的操作一般是一些IO操作，例如網絡請求，文件讀取等。我們使用asyncio.sleep函數來模擬IO操作。協程的目的也是讓這些IO操作異步化。

例如：

 

#coding:utf-8
import asyncio
import threading
import time
async def hello():
    print("hello 1")
    r = await asyncio.sleep(1)
    print("hello 2")


def main():
    loop = asyncio.get_event_loop()

    print("begin")
    loop.run_until_complete(hello())
    loop.close()
    print("end")


if __name__ == "__main__":
    main()

 

 

【五】3.6更新

①可以在同一個協程函數中同時使用await和yield

例如：

import asyncio
async def ticker(delay, to):
    for i in range(to):
        yield i
        await asyncio.sleep(delay)


async def run():
    async for i in ticker(1, 10):
        print(i)

loop = asyncio.get_event_loop()
try:
    loop.run_until_complete(run())
finally:

    loop.close()

 

 

 

 

順帶一提，yield 我們可以暫且認為是一種中斷機制（詳情可以參考官方文檔，這種解釋只是便於說明await）

例如：

 

def a():
    print("first")
    yield
    print("second")
    yield
    print("end")
    yield

if __name__ == "__main__":

    g1=a()
    print("next1")
    g1.__next__()
    print("next2")
    g1.__next__()
    print("next3")
    g1.__next__()

 

 

 

 

②允許在協程函數中異步推導式

例如：

 

async def ticker(delay, to):
    for i in range(to):
        yield i
        await asyncio.sleep(delay)

async def run():
    result = [i async for i in ticker(1, 10) if i%2]
    print(result)
import asyncio
loop = asyncio.get_event_loop()
try:

    loop.run_until_complete(run())
finally:

    loop.close()

 

 

【六】協程並發

定義tasks時可以設置多個ensure，也可以像多線程那樣用append方法實現

 

tasks = [
    asyncio.ensure_future(coroutine1),
    asyncio.ensure_future(coroutine2),
    asyncio.ensure_future(coroutine3)
]

for i in range(4, 6):
    tasks.append(asyncio.ensure_future(do_some_work(i)))

 

當遇到阻塞時可以使用await讓其他協程繼續工作

例如：

 

import asyncio
import time
now = lambda: time.time()

async def do_some_work(x):
    print('Waiting: ', x)

    await asyncio.sleep(x)
    return 'Done after {}s'.format(x)

coroutine1 = do_some_work(1)
coroutine2 = do_some_work(2)
coroutine3 = do_some_work(3)

tasks = [
    asyncio.ensure_future(coroutine1),
    asyncio.ensure_future(coroutine2),
    asyncio.ensure_future(coroutine3)
]

for i in range(4, 6):
    tasks.append(asyncio.ensure_future(do_some_work(i)))

loop = asyncio.get_event_loop()

start = now()
loop.run_until_complete(asyncio.wait(tasks))

for task in tasks:
    print('Task ret: ', task.result())

print('TIME: ', now() - start)

 

 

通過運行時間可以看出aysncio實現了並發。asyncio.wait(tasks) 也可以使用 asyncio.gather(*tasks) ,前者接受一個task列表，后者接收一堆task。

 

【七】協程嵌套

使用async可以定義協程，協程用於耗時的io操作，我們也可以封裝更多的io操作過程，這樣就實現了嵌套的協程，即一個協程中await了另外一個協程，如此連接起來。

 

例如：

 

import asyncio
import time
now = lambda: time.time()
async def do_some_work(x):
    print('Waiting: ', x)

    await asyncio.sleep(x)
    return 'Done after {}s'.format(x)

async def main():
    coroutine1 = do_some_work(1)
    coroutine2 = do_some_work(2)
    coroutine3 = do_some_work(4)

    tasks = [
        asyncio.ensure_future(coroutine1),
        asyncio.ensure_future(coroutine2),
        asyncio.ensure_future(coroutine3)
    ]

    dones, pendings = await asyncio.wait(tasks)

    for task in dones:
        print('Task ret: ', task.result())

start = now()

loop = asyncio.get_event_loop()
loop.run_until_complete(main())

print('TIME: ', now() - start)

 

 

如果使用的是 asyncio.gather創建協程對象，那么await的返回值就是協程運行的結果。

 

#dones, pendings = await asyncio.wait(tasks)
    #for task in dones:
    #print('Task ret: ', task.result())
results = await asyncio.gather(*tasks)
for result in results:
    print('Task ret: ', result)

 

不在main協程函數里處理結果，直接返回await的內容，那么最外層的run_until_complete將會返回main協程的結果。

 

import asyncio
import time
now = lambda: time.time()
async def do_some_work(x):
    print('Waiting: ', x)

    await asyncio.sleep(x)
    return 'Done after {}s'.format(x)

async def main():
    coroutine1 = do_some_work(1)
    coroutine2 = do_some_work(2)
    coroutine3 = do_some_work(4)

    tasks = [
        asyncio.ensure_future(coroutine1),
        asyncio.ensure_future(coroutine2),
        asyncio.ensure_future(coroutine3)
    ]

    return await asyncio.gather(*tasks)

start = now()
loop = asyncio.get_event_loop()
results = loop.run_until_complete(main())
for result in results:
    print('Task ret: ', result)

print('TIME: ', now() - start)

 

 

或者返回使用asyncio.wait方式掛起協程。

 

import asyncio
import time
now = lambda: time.time()
async def do_some_work(x):
    print('Waiting: ', x)

    await asyncio.sleep(x)
    return 'Done after {}s'.format(x)

async def main():
    coroutine1 = do_some_work(1)
    coroutine2 = do_some_work(2)
    coroutine3 = do_some_work(4)

    tasks = [
        asyncio.ensure_future(coroutine1),
        asyncio.ensure_future(coroutine2),
        asyncio.ensure_future(coroutine3)
    ]

    return await asyncio.wait(tasks)

start = now()

loop = asyncio.get_event_loop()
done, pending = loop.run_until_complete(main())

for task in done:
    print('Task ret: ', task.result())

print('TIME: ', now() - start)

 

 

也可以使用asyncio的as_completed方法

 

import asyncio
import time
now = lambda: time.time()
async def do_some_work(x):
    print('Waiting: ', x)

    await asyncio.sleep(x)
    return 'Done after {}s'.format(x)

async def main():
    coroutine1 = do_some_work(1)
    coroutine2 = do_some_work(2)
    coroutine3 = do_some_work(4)

    tasks = [
        asyncio.ensure_future(coroutine1),
        asyncio.ensure_future(coroutine2),
        asyncio.ensure_future(coroutine3)
    ]
    for task in asyncio.as_completed(tasks):
        result = await task
        print('Task ret: {}'.format(result))

start = now()

loop = asyncio.get_event_loop()
done = loop.run_until_complete(main())
print('TIME: ', now() - start)

 

由此可見，協程的調用和組合十分的靈活，我們可以發揮想象盡情的浪