asyncio簡介

示例

首先，我們來看一個簡單的Hello World示例代碼:

import asyncioasync def main():print('Hello ...')await asyncio.sleep(1)print('... World!')asyncio.run(main())""" 
輸出:
Hello ...
... World!
"""

這個例子展示了如何使用 asyncio 庫來編寫并發(fā)代碼。通過 async 和 await 語法，我們可以讓 Python 程序在執(zhí)行IO操作（如計算、文件讀寫、網(wǎng)絡(luò)請求等）時實現(xiàn)在其他任務(wù)間高效切換，從而提升程序性能。

什么是 asyncio?

asyncio 是一個用于編寫并發(fā)代碼的Python庫，允許我們利用 async 和 await 關(guān)鍵字進行異步編程。作為多個Python異步框架的基礎(chǔ)，asyncio 提供了諸如高性能網(wǎng)絡(luò)和Web服務(wù)器、數(shù)據(jù)庫連接庫以及分布式任務(wù)隊列等功能。

適用場景

asyncio 非常適合用于 IO密集型和高層次結(jié)構(gòu)化網(wǎng)絡(luò)代碼處理。其高效的異步IO處理方式，使其在需要大量網(wǎng)絡(luò)通信和異步操作的場景中表現(xiàn)優(yōu)異。

API

高級API用于：

• 并發(fā)運行Python協(xié)程，完全控制它們的執(zhí)行；
• 執(zhí)行網(wǎng)絡(luò)IO和進程間通信（IPC）；
• 控制子進程；
• 通過隊列分發(fā)任務(wù)；
• 同步并發(fā)代碼。

低級API用于（庫和框架開發(fā)人）：

• 創(chuàng)建和管理事件循環(huán)，提供異步API實現(xiàn)網(wǎng)絡(luò)通信、運行子進程、處理OS信號等；
• 使用 transports 實現(xiàn)高效率協(xié)議；
• 用異步語法橋接基于回調(diào)的庫和代碼。

asyncio的使用

可等待對象

什么是可等待對象？

簡單來說，可等待對象是可以在await表達式中使用的對象。它們可以暫停異步函數(shù)的執(zhí)行，等待某個操作完成后再恢復(fù)執(zhí)行。Python中的可等待對象主要包括三種類型：

1. 協(xié)程對象(coroutine objects)
2. 任務(wù)對象(tasks)
3. Future對象(futures)

協(xié)程對象

協(xié)程函數(shù)是定義時使用async def語句的函數(shù)。當調(diào)用協(xié)程函數(shù)時，會返回一個協(xié)程對象。這些對象必須在事件循環(huán)中運行，可以直接被await。

import asyncioasync def main():await asyncio.sleep(1)print("Hello, world!")# 運行協(xié)程
asyncio.run(main())

在上面的示例中，main()是一個協(xié)程函數(shù)，調(diào)用它返回一個協(xié)程對象。asyncio.run(main())將運行事件循環(huán)并執(zhí)行協(xié)程。

任務(wù)對象

任務(wù)對象是對協(xié)程對象的進一步封裝，被用來“并行的”調(diào)度協(xié)程，它們會安排協(xié)程在事件循環(huán)中執(zhí)行，并可以跟蹤協(xié)程的狀態(tài)和結(jié)果?？梢酝ㄟ^asyncio.create_task函數(shù)創(chuàng)建任務(wù)，當一個協(xié)程通過 asyncio.create_task() 等函數(shù)被封裝為一個任務(wù)，該協(xié)程會被自動調(diào)度執(zhí)行。

import asyncioasync def say_hello():await asyncio.sleep(1)print("Hello!")async def main():task = asyncio.create_task(say_hello())await taskasyncio.run(main())

在這個示例中，我們使用asyncio.create_task創(chuàng)建了一個任務(wù)對象，該對象隨后被await，這意味著程序?qū)⒌却蝿?wù)完成。

Future對象

Future對象表示一個將來可能會有結(jié)果的操作，他們主要是用于低級別的異步編程。通常情況下，沒有必要在應(yīng)用層級的代碼中創(chuàng)建 Future 對象。開發(fā)者更多使用高層次的抽象如任務(wù)對象，但了解Future對象仍然很有價值。

import asyncioasync def set_future_value(fut):await asyncio.sleep(1)fut.set_result("Finished!")async def main():fut = asyncio.Future()await asyncio.create_task(set_future_value(fut))result = await futprint(result)asyncio.run(main())

在這個示例中，通過asyncio.Future()創(chuàng)建了一個Future對象，并在一個協(xié)程中使用set_result方法設(shè)置了其結(jié)果。

協(xié)程

什么是協(xié)程？

協(xié)程（Coroutine）是一種比線程更輕量級的“并發(fā)”方式。它允許程序在同一個線程里“并行”地執(zhí)行多個任務(wù)。這里“并行”并不是指真正的并行執(zhí)行，而是協(xié)程可以在任務(wù)之間快速切換，從而讓這些任務(wù)看起來像是同時進行的。

你可以把協(xié)程想象成一個大辦公室里的一名員工，這名員工需要完成一些任務(wù)，比如接電話、發(fā)郵件、寫報告。這些任務(wù)可能需要等一段時間才能完成，比如等電話的對方回復(fù)，等郵件發(fā)送成功，或者等等數(shù)據(jù)。但是在等待的時間里，這名員工不會閑著，他會繼續(xù)去做別的任務(wù)。

• 線程就像是一個員工每做一個任務(wù)他就需要一個獨立的辦公桌。線程是重量級的，需要更多資源，啟動和管理也更復(fù)雜。
• 協(xié)程就像是一個員工在同一個辦公桌上同時處理多個任務(wù)，快速切換。協(xié)程是輕量級的，消耗的資源很少，啟動和管理也比較簡單。

基本使用

• 定義協(xié)程函數(shù)：使用 async def 關(guān)鍵字定義一個協(xié)程函數(shù)。

async def my_coroutine():pass

• 運行協(xié)程：可以使用 await 關(guān)鍵詞等待另一個協(xié)程完成，或使用 asyncio.run() 來運行最頂層的入口點協(xié)程。

import asyncioasync def my_coroutine():print("這是使用await運行的協(xié)程")async def main():print("使用asyncio.run運行協(xié)程開始")await my_coroutine()print("使用asyncio.run運行協(xié)程結(jié)束")asyncio.run(main())"""
輸出：
使用asyncio.run運行協(xié)程開始
這是使用await運行的協(xié)程
使用asyncio.run運行協(xié)程結(jié)束
"""

注意：簡單地調(diào)用一個協(xié)程并不會使其被調(diào)度執(zhí)行

# python console 中運行
async def my_coroutine():print("my coroutine")my_coroutine()
<coroutine object my_coroutine at 0x104519f50>

運行協(xié)程

• 使用asyncio.run() 函數(shù)用來運行最頂層的入口點 “main()” 函數(shù) (見上面的示例)

• 使用await執(zhí)行（以下代碼段會在等待3秒后打印 "1號協(xié)程"結(jié)束時間，然后再次等待5秒后打印 "2號協(xié)程"完成時間）

  import asyncio
  import timeasync def my_coroutine(name, delay):await asyncio.sleep(delay)  # 模擬I/O操作print(f"{name}完成時間：{time.time()}")async def main():start_time = time.time()print(f"開始時間 {start_time}")await my_coroutine("1號協(xié)程", 3)await my_coroutine("2號協(xié)程", 5)end_time = time.time()print(f"結(jié)束時間 {end_time}")print(f"耗時{end_time - start_time:.2f}秒")asyncio.run(main())"""
  輸出：
  開始時間 1726210238.44529
  1號協(xié)程完成時間：1726210241.446931
  2號協(xié)程完成時間：1726210246.4494321
  結(jié)束時間 1726210246.449468
  耗時8.00秒
  """
  

• asyncio.create_task() 函數(shù)用來并發(fā)運行作為 asyncio 任務(wù)的多個協(xié)程。（修改以上示例，并發(fā)運行兩個協(xié)程）

  import asyncio
  import timeasync def my_coroutine(name, delay):await asyncio.sleep(delay)  # 模擬I/O操作print(f"{name}完成時間：{time.time()}")async def main():start_time = time.time()print(f"開始時間 {start_time}")task1 = asyncio.create_task(my_coroutine("1號協(xié)程", 3))task2 = asyncio.create_task(my_coroutine("2號協(xié)程", 5))await task1await task2end_time = time.time()print(f"結(jié)束時間 {end_time}")print(f"耗時{end_time - start_time:.2f}秒")asyncio.run(main())"""
  輸出：
  開始時間 1726210659.84198
  1號協(xié)程完成時間：1726210662.843559
  2號協(xié)程完成時間：1726210664.842549
  結(jié)束時間 1726210664.84267
  耗時5.00秒
  """
  # 可以明顯看出總耗時比之前明顯快了3秒，1和2之間的時間間隔也變成了2秒
  

• asyncio.TaskGroup 類提供了 create_task() 的替代。 使用此 API，之前的例子可以改為

  async def main():start_time = time.time()print(f"開始時間 {start_time}")async with asyncio.TaskGroup() as tg:task1 = tg.create_task(my_coroutine("1號協(xié)程", 3))task2 = tg.create_task(my_coroutine("2號協(xié)程", 5))end_time = time.time()print(f"結(jié)束時間 {end_time}")print(f"耗時{end_time - start_time:.2f}秒")
  

Task

什么是 Task？

在 asyncio 中，Task 是對協(xié)程進行調(diào)度管理的對象。Task 實際上是 asyncio 事件循環(huán)的一個抽象概念，通過 Task 我們可以控制協(xié)程（coroutine）的執(zhí)行，允許它們并發(fā)運行。在底層，Task 使用事件循環(huán)調(diào)度多個協(xié)程，使得它們似乎是同時運行的。

asyncio.Task 對象可以被看作是 Future 的一種特化，用于運行 Python 協(xié)程。它們被設(shè)計用來在事件循環(huán)中調(diào)度和運行協(xié)程。
Task對象是非線程安全的，意味著它們主要用于單線程的 asyncio 事件循環(huán)。

創(chuàng)建 Task

• 使用 asyncio.create_task() 方法，
  asyncio.create_task() 是創(chuàng)建 Task 的最常見方法，它會立即調(diào)度協(xié)程的運行并返回一個 Task 對象：

  import asyncio
  import timeasync def my_coroutine():print(f"協(xié)程開始時間 {time.strftime('%X')}")await asyncio.sleep(2)print(f"協(xié)程結(jié)束時間 {time.strftime('%X')}")async def main():print(f"主協(xié)程開始時間：{time.strftime('%X')}")# 創(chuàng)建一個 Tasktask = asyncio.create_task(my_coroutine())print(f"任務(wù)創(chuàng)建時間：{time.strftime('%X')}")# 稍微等待一下，但不會 await Taskawait asyncio.sleep(5)print(f"延時結(jié)束，開始等待任務(wù)：{time.strftime('%X')}")# 現(xiàn)在等待 Task 完成await taskprint(f"主協(xié)程結(jié)束時間：{time.strftime('%X')}")# 運行主協(xié)程
  asyncio.run(main())"""
  輸出：
  主協(xié)程開始時間：17:45:30
  任務(wù)創(chuàng)建時間：17:45:30
  協(xié)程開始時間 17:45:30
  協(xié)程結(jié)束時間 17:45:32
  延時結(jié)束，開始等待任務(wù)：17:45:35
  主協(xié)程結(jié)束時間：17:45:35
  """
  

  在上面的示例中，asyncio.create_task(my_coroutine()) 創(chuàng)建了一個 Task，它會立即開始運行 my_coroutine 協(xié)程，即使我還并沒有執(zhí)行await。

• 使用 loop.create_task() 方法

  我們還可以通過獲取事件循環(huán)，然后調(diào)用它的 create_task 方法來創(chuàng)建任務(wù)：

  import asyncio
  import timeasync def my_coroutine():print(f"協(xié)程開始時間 {time.strftime('%X')}")await asyncio.sleep(2)print(f"協(xié)程結(jié)束時間 {time.strftime('%X')}")async def main():print(f"主協(xié)程開始時間：{time.strftime('%X')}")# 創(chuàng)建一個 Taskloop = asyncio.get_running_loop()task = loop.create_task(my_coroutine())print(f"任務(wù)創(chuàng)建時間：{time.strftime('%X')}")# 稍微等待一下，但不會 await Taskawait asyncio.sleep(5)print(f"延時結(jié)束，開始等待任務(wù)：{time.strftime('%X')}")# 現(xiàn)在等待 Task 完成await taskprint(f"主協(xié)程結(jié)束時間：{time.strftime('%X')}")# 運行主協(xié)程
  asyncio.run(main())"""
  輸出：
  主協(xié)程開始時間：17:50:03
  任務(wù)創(chuàng)建時間：17:50:03
  協(xié)程開始時間 17:50:03
  協(xié)程結(jié)束時間 17:50:05
  延時結(jié)束，開始等待任務(wù)：17:50:08
  主協(xié)程結(jié)束時間：17:50:08
  """
  

  在上面的示例中，使用asyncio.get_running_loop() 獲取當前正在運行的事件循環(huán)，loop.create_task(my_coroutine()) 使用事件循環(huán)的 create_task 方法創(chuàng)建并調(diào)度一個協(xié)程任務(wù)。
  asyncio.create_task()與loop.create_task()的不同之處：

  • asyncio.create_task()：是一個便捷方法，直接通過當前的默認事件循環(huán)創(chuàng)建任務(wù)
  • loop.create_task()：需要明確提供事件循環(huán)，適用于更復(fù)雜或特定需求的場景，比如管理多個事件循環(huán)。

• 使用 asyncio.ensure_future()
  雖然不如前兩種方法常用，但 asyncio.ensure_future 也可以用來創(chuàng)建 Task。它可以接受協(xié)程或 Future 對象，并確保返回一個 Task：

  import asyncio
  import timeasync def my_coroutine():print(f"協(xié)程開始時間 {time.strftime('%X')}")await asyncio.sleep(2)print(f"協(xié)程結(jié)束時間 {time.strftime('%X')}")async def main():print(f"主協(xié)程開始時間：{time.strftime('%X')}")# 創(chuàng)建一個 Tasktask = asyncio.ensure_future(my_coroutine())print(f"任務(wù)創(chuàng)建時間：{time.strftime('%X')}")# 稍微等待一下，但不會 await Taskawait asyncio.sleep(5)print(f"延時結(jié)束，開始等待任務(wù)：{time.strftime('%X')}")# 現(xiàn)在等待 Task 完成await taskprint(f"主協(xié)程結(jié)束時間：{time.strftime('%X')}")# 運行主協(xié)程
  asyncio.run(main())"""
  輸出：
  主協(xié)程開始時間：18:00:54
  任務(wù)創(chuàng)建時間：18:00:54
  協(xié)程開始時間 18:00:54
  協(xié)程結(jié)束時間 18:00:56
  延時結(jié)束，開始等待任務(wù)：18:00:59
  主協(xié)程結(jié)束時間：18:00:59
  """
  

  asyncio.ensure_future() 是一個功能強大的函數(shù)，常用于將一個協(xié)程轉(zhuǎn)換為一個 Future 對象。
  它在處理異步任務(wù)時提供了更多的靈活性，特別是在需要將協(xié)程包裝為 Future 時。
  asyncio.create_task() 和 asyncio.ensure_future() 的不同之處：

  • asyncio.create_task()：專門用于將協(xié)程轉(zhuǎn)換為 Task，只能處理協(xié)程對象。
  • asyncio.ensure_future()：可以處理協(xié)程對象和 Future 對象，更加通用，適用于更多場景。

取消 Task

在 asyncio 中，當一個 Task 對象的 cancel() 方法被調(diào)用時，它會請求取消該任務(wù)。具體步驟如下：

1. 標記任務(wù)為取消狀態(tài)：調(diào)用 cancel() 方法后，任務(wù)會被標記為取消狀態(tài)。
2. 拋出 CancelledError 異常：再次調(diào)度這個任務(wù)時，它會在等待的位置拋出一個 asyncio.CancelledError 異常。
3. 任務(wù)處理異常：協(xié)程內(nèi)部可以捕獲這個異常，進行相應(yīng)的清理操作。

import asyncioasync def cancellable_task():try:print("Task 啟動")await asyncio.sleep(10)  # 長時間任務(wù)print("Task 完成")except asyncio.CancelledError:print("Task 被取消")raise  # 重新拋出err，以便外部可以檢測到任務(wù)已被取消async def main():task = asyncio.create_task(cancellable_task())await asyncio.sleep(2)  # 等待一段時間task.cancel()  # 請求取消任務(wù)try:await taskexcept asyncio.CancelledError:print("主協(xié)程: Task 被取消")asyncio.run(main())"""
輸出：
Task 啟動
Task 被取消
主協(xié)程: Task 被取消
"""

在這個例子中，main() 協(xié)程啟動了一個長時間運行的任務(wù) cancellable_task() 并在2秒后請求取消它。

Task 異常獲取

在 asyncio 中，Task 對象繼承了 Future 對象的許多方法和屬性，其中包括 exception() 方法。exception() 用于獲取任務(wù)在執(zhí)行過程中拋出的異常。如果任務(wù)完成且沒有異常發(fā)生，exception() 返回 None。如果任務(wù)還未完成，調(diào)用 exception() 將會引發(fā) asyncio.InvalidStateError 異常。因此，通常我們需要在任務(wù)完成之后調(diào)用 exception() 方法。

import asyncioasync def my_task():await asyncio.sleep(1)raise ValueError("任務(wù)執(zhí)行出錯")async def main():task = asyncio.create_task(my_task())try:await taskexcept Exception as e:print(f"主協(xié)程中捕獲異常: {e}")# 現(xiàn)在任務(wù)已經(jīng)完成，可以檢查異常if task.exception():print(f"任務(wù)結(jié)束通過exception方法檢查異常: {task.exception()}")asyncio.run(main())"""
輸出：
主協(xié)程中捕獲異常: 任務(wù)執(zhí)行出錯
任務(wù)結(jié)束通過exception方法檢查異常: 任務(wù)執(zhí)行出錯
"""

在這個示例中，my_task() 會拋出一個 ValueError 異常。我們在主協(xié)程 main() 中捕獲該異常，同時也通過 exception() 方法再次獲取并打印異常。

Task 回調(diào)

add_done_callback() 方法是 asyncio 提供的一個強大的工具，允許我們在任務(wù)完成后執(zhí)行特定的回調(diào)函數(shù)?；卣{(diào)函數(shù)幫助我們更有效地管理任務(wù)的生命周期，處理結(jié)果和異常，并執(zhí)行一些后續(xù)操作。

import asyncioasync def my_task():await asyncio.sleep(1)  # 模擬一些異步操作return "一鍵三連"def task_done_callback(future):print(f"回調(diào)-任務(wù)已完成，結(jié)果: {future.result()}")async def main():task = asyncio.create_task(my_task())task.add_done_callback(task_done_callback)await task  # 等待任務(wù)完成asyncio.run(main())"""
輸出：
回調(diào)-任務(wù)已完成，結(jié)果: 一鍵三連
"""

在這個例子中，task_done_callback 回調(diào)函數(shù)會在 my_task 任務(wù)完成后被調(diào)用，并打印任務(wù)的結(jié)果。

import asyncioasync def failing_task():await asyncio.sleep(1)raise ValueError("任務(wù)出現(xiàn)了奇怪的錯誤")def task_done_callback(future):if future.exception():print(f"回調(diào)-任務(wù)失敗，異常: {future.exception()}")else:print(f"回調(diào)-任務(wù)完成，結(jié)果: {future.result()}")async def main():task = asyncio.create_task(failing_task())task.add_done_callback(task_done_callback)try:await taskexcept Exception as e:print(f"主協(xié)程捕獲異常: {e}")asyncio.run(main())"""
輸出：
回調(diào)-任務(wù)失敗，異常: 任務(wù)出現(xiàn)了奇怪的錯誤
主協(xié)程捕獲異常: 任務(wù)出現(xiàn)了奇怪的錯誤
"""

在這個示例中，當 failing_task 拋出異常時，task_done_callback 會檢測并打印異常，而主協(xié)程也會捕獲并處理該異常。

TaskGroup

什么是 TaskGroup？

TaskGroup 是 Python 3.11 中新增的 asyncio 組件。它提供了一種更簡潔、更安全的方式來管理多個并發(fā)任務(wù)。TaskGroup 是一個上下文管理器，當與 async with 語句一起使用時，它允許我們在一個塊內(nèi)啟動多個任務(wù)，并確保這些任務(wù)在上下文管理器退出時正確清理。

為什么使用 TaskGroup？

1. 更簡潔的語法：在沒有 TaskGroup 之前，管理多個任務(wù)通常需要手動創(chuàng)建每個任務(wù)并在最后通過 await 語句等待所有任務(wù)完成。TaskGroup 簡化了這一過程。
2. 更好的錯誤處理：由于 TaskGroup 是一個上下文管理器，它更容易管理任務(wù)中的異常情況。
3. 更清晰的結(jié)構(gòu)：代碼的可讀性和結(jié)構(gòu)性得到了顯著提升。

創(chuàng)建任務(wù)

在 TaskGroup 中創(chuàng)建任務(wù)使用 create_task 方法。每個任務(wù)會立即調(diào)度，并在 TaskGroup 的管理范圍內(nèi)運行。

import asyncio
import timeasync def task(n):print(f"任務(wù) {n} 啟動 {time.strftime('%X')}")await asyncio.sleep(2)print(f"任務(wù) {n} 結(jié)束 {time.strftime('%X')}")async def main():async with asyncio.TaskGroup() as tg:tg.create_task(task(1))tg.create_task(task(2))tg.create_task(task(3))asyncio.run(main())"""
輸出：
任務(wù) 1 啟動 17:08:18
任務(wù) 2 啟動 17:08:18
任務(wù) 3 啟動 17:08:18
任務(wù) 1 結(jié)束 17:08:20
任務(wù) 2 結(jié)束 17:08:20
任務(wù) 3 結(jié)束 17:08:20
"""

在這個示例中，我們通過 async with 語句創(chuàng)建了一個 TaskGroup，并使用 create_task 方法啟動了三個并行運行的任務(wù) task(n)，這三個任務(wù)立即調(diào)度，并在 TaskGroup 的管理范圍內(nèi)運行。當所有任務(wù)完成時，TaskGroup 會自動進行清理。

異常處理

當 TaskGroup 中的任務(wù)引發(fā)異常時，異常會在退出 async with 塊時處理。如果多個任務(wù)引發(fā)異常，TaskGroup 會聚合這些異常，并引發(fā)一個 ExceptionGroup 異常。

import asyncioasync def error_task():raise RuntimeError("一些奇怪的錯誤")async def main():try:async with asyncio.TaskGroup() as tg:tg.create_task(error_task())tg.create_task(error_task())tg.create_task(error_task())except ExceptionGroup as e:print("任務(wù)組捕獲異常: ", e)asyncio.run(main())"""
輸出：
任務(wù)組捕獲異常:  unhandled errors in a TaskGroup (3 sub-exceptions)
"""

在使用 asyncio.TaskGroup 時，如果多個任務(wù)引發(fā)異常，異常會被聚合成一個 ExceptionGroup 異常，并在 TaskGroup 上下文管理器退出時被捕獲和處理。然而，默認情況下，ExceptionGroup 只提供較為簡略的信息。要看到具體的子異常信息，我們需要更詳細地打印 ExceptionGroup 對象。

import asyncioasync def error_task():raise RuntimeError("一些奇怪的錯誤")async def main():try:async with asyncio.TaskGroup() as tg:tg.create_task(error_task())tg.create_task(error_task())tg.create_task(error_task())except ExceptionGroup as e:print("任務(wù)組捕獲異常:")for sub_exception in e.exceptions:print(f"子異常: {sub_exception}")asyncio.run(main())"""
輸出：
任務(wù)組捕獲異常:
子異常: 一些奇怪的錯誤
子異常: 一些奇怪的錯誤
子異常: 一些奇怪的錯誤
"""

在上面的示例中，我們在捕獲 ExceptionGroup 異常后，迭代其 exceptions 屬性，逐個打印出子異常的信息。這樣可以更全面了解 ExceptionGroup 中包含的所有異常。

同步任務(wù)完成

TaskGroup 保證所有任務(wù)在同一個上下文管理器范圍內(nèi)完成。如果某個任務(wù)需要較長時間完成，其他任務(wù)會等待它。

import asyncioasync def long_task():await asyncio.sleep(5)print("長任務(wù)完成")async def short_task():await asyncio.sleep(1)print("短任務(wù)完成")async def main():async with asyncio.TaskGroup() as tg:tg.create_task(long_task())tg.create_task(short_task())print("所有任務(wù)完成")asyncio.run(main())"""
輸出：
短任務(wù)完成
長任務(wù)完成
所有任務(wù)完成
"""

上面的示例展示了如何使用 asyncio.TaskGroup 同時管理多個異步任務(wù)，其中短任務(wù)先完成并輸出結(jié)果，長任務(wù)隨后完成，最終確保所有任務(wù)結(jié)束后輸出 “所有任務(wù)完成”。