python asyncio 協程庫的使用

asyncio 是 python 力推多年的攜程庫,與其 線程庫 相得益彰,更輕量,並且協程可以訪問同一進程中的變量,不需要進程間通信來傳遞數據,所以使用起來非常順手。

asyncio 官方文檔寫的非常簡練和有效,半小時內可以學習和測試完,下面為我的一段 HelloWrold,感覺可以更快速的幫你認識 協程 。

定義協程

import asyncio
import time


async def say_after(delay, what):
  await asyncio.sleep(delay)
  print(what)

async 關鍵字用來聲明一個協程函數,這種函數不能直接調用,會拋出異常。正確的調用姿勢有:

await 協程()
await asyncio.gather(協程1(), 協程2())
await asyncio.waite([協程1(), 協程2()])
asyncio.create_task(協程())

await 阻塞式調用協程

先來測試前 3 種 await 的方式:

async def main1():
  # 直接 await,順序執行
  await say_after(2, "2s")
  await say_after(1, "1s")


async def main2():
  # 使用 gather,並發執行
  await asyncio.gather(say_after(2, "2s"), say_after(1, "1s"))


async def main3():
  # 使用 wait,簡單等待
  # 3.8 版後已廢棄: 如果 aws 中的某個可等待對象為協程,它將自動作為任務加入日程。直接向 wait() 傳入協程對象已棄用,因為這會導致 令人迷惑的行為。
  # 3.10 版後移除
  await asyncio.wait([say_after(2, "2s"), say_after(1, "1s")])

python 規定: 調用協程可以用 await,但 await 必須在另一個協程中 —— 這不死循環瞭?不會的,asyncio 提供瞭多個能夠最初調用協程的入口:

asyncio.get_event_loop().run_until_complete(協程)
asyncio.run(協程)

封裝一個計算時間的函數,然後把 2 種方式都試一下:

def runtime(entry, func):
  print("-" * 10 + func.__name__)
  start = time.perf_counter()
  entry(func())
  print("=" * 10 + "{:.5f}".format(time.perf_counter() - start))

print("########### 用 loop 入口協程 ###########")

loop = asyncio.get_event_loop()
runtime(loop.run_until_complete, main1)
runtime(loop.run_until_complete, main2)
runtime(loop.run_until_complete, main3)
loop.close()

print("########### 用 run 入口協程 ###########")

runtime(asyncio.run, main1)
runtime(asyncio.run, main2)
runtime(asyncio.run, main3)

運行結果:

########### 用 loop 入口協程 ###########
----------main1
2s
1s
==========3.00923
----------main2
1s
2s
==========2.00600
----------main3
1s
2s
==========2.00612
########### 用 run 入口協程 ###########
----------main1
2s
1s
==========3.01193
----------main2
1s
2s
==========2.00681
----------main3
1s
2s
==========2.00592

可見,2 種協程入口調用方式差別不大

下面,需要明確 2 個問題:

協程間的並發問題 :除瞭 main1 耗時 3s 外,其他都是 2s,說明 main1 方式串行執行 2 個協程,其他是並發執行協程。
協程是否阻塞父協程/父進程的問題 :上述測試都使用瞭 await,即等待協程執行完畢後再繼續往下走,所以都是阻塞式的,主進程都在此等待協程的執行完。—— 那麼如何才能不阻塞父協程呢? 不加 await 行麼? —— 上面 3 種方式都不行!
下面介紹可以不阻塞主協程的方式。

task 實現更靈活的協程

一切都在代碼中:

# 驗證 task 啟動協程是立即執行的
async def main4():
  # create_task() Python 3.7 中被加入
  task1 = asyncio.create_task(say_after(2, "2s"))
  task2 = asyncio.create_task(say_after(1, "1s"))
  # 創建任務後會立即開始執行,後續可以用 await 來等待其完成後再繼續,也可以被 cancle
  await task1 # 等待 task1 執行完,其實返回時 2 個task 都已經執行完
  print("--") # 最後才會被打印,因為 2 個task 都已經執行完
  await task2
  # 這裡是等待所有 task 結束才繼續運行。


# 驗證父協程與子協程的關閉關系
async def main5():
  task1 = asyncio.create_task(say_after(2, "2s"))
  task2 = asyncio.create_task(say_after(1, "1s"))
  # 如果不等待,函數會直接 return,main5 協程結束,task1/2 子協程也結束,所以看不到打印
  # 此處等待 1s,則會隻看到 1 個,等待 >2s,則會看到 2 個 task 的打印
  await asyncio.sleep(2)


# python3.8 後 python 為 asyncio 的 task 增加瞭很多功能:
# get/set name、獲取正在運行的 task、cancel 功能
# 驗證 task 的 cancel() 功能
async def cancel_me(t):
  # 定義一個可處理 CancelledError 的協程
  print("cancel_me(): before sleep")
  try:
    await asyncio.sleep(t)
  except asyncio.CancelledError:
    print("cancel_me(): cancel sleep")
    raise
  finally:
    print("cancel_me(): after sleep")
  return "I hate be canceled"


async def main6():
  async def test(t1, t2):
    task = asyncio.create_task(cancel_me(t1))
    await asyncio.sleep(t2)
    task.cancel() # 會在 task 內引發一個 CancelledError
    try:
      await task
    except asyncio.CancelledError:
      print("main(): cancel_me is cancelled now")
    try:
      print(task.result())
    except asyncio.CancelledError:
      print("main(): cancel_me is cancelled now")

  # 讓其運行2s,但在1s時 cancel 它
  await test(2, 1) # await 和 result 時都會引發 CancelledError
  await test(1, 2) # await 和 result 時不會引發,並且 result 會得到函數的返回值

runtime(asyncio.run, main4)
runtime(asyncio.run, main5)
runtime(asyncio.run, main6)

運行結果:

----------main4
1s
2s
--
==========2.00557
----------main5
1s
2s
==========3.00160
----------main6
cancel_me(): before sleep
cancel_me(): cancel sleep
cancel_me(): after sleep
main(): cancel_me is cancelled now
main(): cancel_me is cancelled now
cancel_me(): before sleep
cancel_me(): after sleep
I hate be canceled
==========3.00924

技術總結

細節都在註釋裡直接描述瞭,總結一下:

  • await 會阻塞主協程,等待子協程完成
  • await asyncio.gather/wait() 可以實現多個子協程的並發執行
  • await 本身要在協程中執行,即在父協程中執行
  • asyncio.get_event_loop().run_until_complete() 和 asyncio.run() 可作為最初的協程開始入口
  • task 是最新、最推薦的協程方式,可以完成阻塞、非阻塞,
  • task = asyncio.create_task(協程) 後直接開始執行瞭,並不會等待其他指令
  • await task 是阻塞式,等待 task 執行結束
  • 不 await,非阻塞,但要此時父協程不能退出,否則 task 作為子協程也被退出
  • task 可 cancel() 取消功能,可 result() 獲取子協程的返回值

以上就是python asyncio 協程庫的使用的詳細內容,更多關於python asyncio 協程庫的資料請關註WalkonNet其它相關文章!

推薦閱讀: