Python 異步協程 async/await/asyncio

原創 _Tsun 2020-06-20 23:24

文章目錄

異步IO asyncio協程

asyncio 是python3.4 引入的，內置的對異步IO的支持。

asyncio編程是一個消息循環，我們從asyncio中獲取一個EventLoop引用

然後把協程放到EventLoop中執行，就實現了異步IO

協程常見名字

先了解以下名詞,有助於理解程序編寫

  • event_loop 事件循環： 程序開啓一個循環，我們把函數註冊到loop裏，滿足條件就會執行

  • coroutine 協程: async def 定義的函數，它不能直接執行,返回的是協程對象,它要註冊到loop中，由loop去執行調用

  • task 任務： 一個協程對象就是一個原生可以掛起的函數，任務則是對協程對象進一步封裝，增加了任務的各種狀態，（比如未執行，執行中，執行結束，返回結果等等？。）

    task 是 future的子類

  • future : 代表將來執行或沒有執行的任務的結果，它個task沒有本質區別

  • async/await : python3.5 用於定義協程的關鍵字

創建一個協程 Coroutine

import asyncio,time

# 記錄開始時間
now = lambda: time.time()
start = now()

# 01.定義一個協程
async def do_work(num):
    print("num:",num)

coroutine = do_work(1)

# 02.創建事件循環
loop = asyncio.get_event_loop()

# 03.將協程對象放入事件循環中
loop.run_until_complete(coroutine)

# 記錄結束時間
print(now() - start)

創建一個任務 Task

loop.run_until_complete方法傳入協程，自動將協程裝成任務task，它也可以直接接收task

創建task 使用以下方法都可以

asyncio.ensure_future(coroutine)

loop.create_task(coroutine)

task是future的子類。

isinstance(task,asyncio.Future) 返回Ture

import asyncio,time

# 記錄開始時間
now = lambda: time.time()
start = now()

# 01.定義一個協程
async def do_work(num):
    print("num:",num)

coroutine = do_work(1)

# 02.創建事件循環
loop = asyncio.get_event_loop()

# 03.創建任務Task
task = asyncio.ensure_future(coroutine)
# 或者下面的方式 創建task也可以
# task = loop.create_task(coroutine)

# 04.將任務註冊到事件循環中
loop.run_until_complete(task)

# 記錄結束時間
print(now() - start)

獲取返回結果 回調函數future/直接使用Task獲取

import asyncio,time

# 記錄開始時間
now = lambda: time.time()
start = now()

# 01.定義一個協程
async def do_work(num):
    print("num:",num)
    return "num is {}".format(num)

coroutine = do_work(3)


# 02.定義回調函數
def callback(future):
    print('result is',future.result())

# 03.創建事件循環
loop = asyncio.get_event_loop()

# 04.創建任務Task
task = loop.create_task(coroutine)

# 05.給task任務綁定回調函數
task.add_done_callback(callback)

# 06.將任務註冊到事件循環中
loop.run_until_complete(task)

# 記錄結束時間
print(now() - start)

不綁定回調，直接使用Task的結果

task.result()，必須任務執行完畢後纔有這個，不然會報錯

阻塞 await

import asyncio,time

# 記錄開始時間
now = lambda: time.time()
start = now()

# 01.定義一個協程
async def do_work(num):
    print("num:",num)
    await asyncio.sleep(num)
    return "sleep is {}".format(num)

coroutine = do_work(3)


# 02.創建事件循環
loop = asyncio.get_event_loop()

# 03.創建任務Task
task = loop.create_task(coroutine)
print(task.result())

# 04.將任務註冊到事件循環中
loop.run_until_complete(task)

# 記錄結束時間
print(now() - start)
print(task.result())

asyncio 實現併發

import asyncio,time

# 記錄開始時間
now = lambda: time.time()
start = now()

# 01.定義一個協程
async def do_work(num):
    print("num:",num)
    await asyncio.sleep(num)
    return "sleep is {}".format(num)

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



# 02.創建任務Task
tasks =[
    asyncio.ensure_future(coroutine1),
    asyncio.ensure_future(coroutine2),
    asyncio.ensure_future(coroutine3),
    
]

# 02.創建事件循環
loop = asyncio.get_event_loop()

# 04.將任務註冊到事件循環中
loop.run_until_complete(asyncio.wait(tasks))

# 記錄結束時間
print(now() - start)
for task in tasks:
    print(task.result())

協程嵌套

import time
import asyncio


async def do_work(x):
    print("do...work.....")
    await asyncio.sleep(x)
    return 'Done result'


async def main():
    # 創建多個協程對象
    coroutine1 = do_work(1)
    coroutine2 = do_work(2)
    coroutine3 = do_work(4)
    
    tasks = [
        asyncio.ensure_future(coroutine1),
        asyncio.ensure_future(coroutine2),
        asyncio.ensure_future(coroutine3)
    ]
    
    # --------------------------------------------
    # 獲取返回結果的方式 1
    dones,pendings = await asyncio.wait(tasks)
    # dones 是任務
    for task in dones:
        print(task.result())
    # --------------------------------------------
    
# 將協程main 放入到 loop中
loop = asyncio.get_event_loop()
loop.run_until_complete(main())

# 獲取返回結果的方式2
results =  await asyncio.gather(*tasks)
for result in results():
    print(result)

# 獲取方式3,不在main中獲取，而是在外面獲取
async def main:
    # .....
    return await asyncio.gather(*tasks)

results = loop.run_until_complete(main())
for result in results():
    print(result)

# 獲取方式4,不在main中獲取，而是在外面獲取
async def main:
    # .....
    return await asyncio.wait(tasks)

dones,pendings = loop.run_until_complete(main())
for task in dones:
    print(task.result())

# 獲取方式5,還是在main中

for task in asyncio.as_complete(tasks):
    result = await task
    print(result)

協程的停止

future 中的幾種狀態

  • Pending 創建future的時候，task爲 pending
  • Running 事件循環執行的時候，task是running
  • Done 執行完畢 task狀態是done
  • Cancelled 任務取消
import time
import asyncio


async def do_work(x):
    print("do...work.....")
    await asyncio.sleep(x)
    return 'Done result'


coroutine1 = do_work(1)
coroutine2 = do_work(2)
coroutine3 = do_work(4)


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


start = time.time()
loop = asyncio.get_event_loop()

try:
    loop.run_until_complete(asyncio.wait(tasks))
except KeyboardInterrupt as e:
    for task in asyncio.Task.all_tasks():
        print(task.cancel())
    loop.stop()
    loop.run_forever()
finally:
    loop.close()

print(time.time() - start)
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

python3異步編程，異步orm之 tortoise-orm

前言: 去年下半年爲了做了個web服務，使用了基於python3.5+的一個異步框架 sanic。 其中需要一個異步的mysql引擎，我們常見的也就是 aiomysql，爲了便於開發，我找了一個基於 aiomysql 的簡單封裝的異步引擎

A-f 2020-06-16 16:11:41

線程中使用事件循環

_Tsun 2019-10-26 10:36:10