I. Python `asyncio` — Principles & Core Mechanics#

Overview: asyncio is Python's asynchronous concurrency framework (异步并发框架) that uses an Event Loop (事件循环), Coroutines (协程), and non-blocking I/O (非阻塞 I/O) to efficiently handle many I/O-bound tasks within a single thread. The core principle: when a coroutine reaches an await, it yields control back to the event loop, which uses OS-level I/O multiplexing to resume the coroutine once the I/O operation is ready.

1. How `asyncio` Works — The Big Picture#

The three pillars of asyncio:

Event Loop (事件循环) — schedules and runs coroutines, monitors I/O events, resumes tasks when they are ready
Coroutines (协程) — define asynchronous tasks using async/await; can pause and resume execution
Non-blocking I/O (非阻塞 I/O) — allows the program to perform other work while waiting for I/O operations to complete

Note: The principle of asyncio is: use an event loop to schedule coroutines (使用事件循环调度协程). When a coroutine reaches await, it yields control (让出执行权) back to the event loop, which then uses non-blocking I/O and OS I/O multiplexing (I/O 多路复用) to resume the coroutine (恢复协程执行) once the I/O operation is ready.

2. Event Loop (事件循环)#

1) What the Event Loop Does#

The Event Loop is the core scheduler (核心调度器) of asyncio. It is responsible for:

Running coroutines and tasks
Monitoring I/O events (sockets, file descriptors, timers)
Resuming coroutines when their awaited operation completes

2) Starting the Event Loop#

The standard way is via asyncio.run():

1
import asyncio
2

3
async def main():
4
    print("hello")
5

6
asyncio.run(main())

What happens here:

asyncio.run() creates and starts the event loop
The event loop executes the main() coroutine to completion
The event loop is closed when the coroutine returns

3. Coroutines (协程)#

1) What Is a Coroutine?#

A Coroutine is a special function that can pause and resume execution. When it encounters an I/O wait, it pauses and returns control to the event loop, allowing other tasks to run in the meantime.

2) How to Define and Use Coroutines#

Define with async def, await with await:

1
import asyncio
2

3
async def task():
4
    await asyncio.sleep(1)
5
    print("done")
6

7
asyncio.run(task())

What happens here:

async def defines the coroutine
await pauses the coroutine until the operation completes, yielding control back to the event loop

Note: Calling an async def function does not execute it — it returns a Coroutine Object (协程对象). The coroutine only runs when it is await-ed or wrapped in a Task via asyncio.create_task().

💡 One-line Takeaway
asyncio achieves concurrency on a single thread by having the Event Loop (事件循环) continuously schedule Coroutines (协程) — each coroutine runs until it hits an await, yields control, and is resumed by the event loop once its I/O is ready.

II. Python `asyncio` — Complete API Reference & Usage Scenarios#

Overview: This note is a complete API reference for Python's asyncio library, organized by category. Every interface is paired with a real-world usage scenario so you can immediately see when and why to use it. The library is built on a single-threaded Event Loop (事件循环) that schedules Coroutines (协程) cooperatively, making it ideal for I/O-bound (I/O 密集型) workloads.

1. Entry Points — Running Coroutines#

1) `asyncio.run(coro)`#

The top-level entry point for running an async program. Creates a new Event Loop (事件循环), runs the coroutine to completion, then closes the loop.

1
import asyncio
2

3
async def main():
4
    print("Hello from asyncio!")
5

6
asyncio.run(main())

Note: Never call asyncio.run() inside an already-running event loop (e.g., inside Jupyter Notebook). Use await coro directly instead, or apply nest_asyncio.

Scenario: Entry point of any standalone async application — CLI tools, scripts, servers.

2) `asyncio.get_event_loop()` / `asyncio.get_running_loop()`#

1
async def main():
2
    loop = asyncio.get_running_loop()   # Preferred inside async context
3
    print(loop)
4

5
loop = asyncio.get_event_loop()         # Can be used outside async context

API	When to Use
`get_running_loop()`	Inside a coroutine — raises `RuntimeError` if no loop is running
`get_event_loop()`	Outside a coroutine — may create a new loop if none exists

2. Coroutines & Tasks (协程与任务)#

1) `async def` / `await` — Defining and Awaiting Coroutines#

1
async def fetch(url: str) -> str:
2
    await asyncio.sleep(1)      # Yield control to event loop
3
    return f"data from {url}"
4

5
async def main():
6
    result = await fetch("https://api.example.com")
7
    print(result)

Scenario: Any function that performs I/O — HTTP requests, DB queries, file reads.

2) `asyncio.create_task(coro)` — Schedule Concurrently#

Wraps a coroutine into a Task (任务) and schedules it to run on the current event loop immediately — without blocking the caller.

1
async def worker(name: str, delay: float):
2
    await asyncio.sleep(delay)
3
    print(f"{name} done")
4

5
async def main():
6
    t1 = asyncio.create_task(worker("A", 2.0))
7
    t2 = asyncio.create_task(worker("B", 1.0))
8
    await t1
9
    await t2
10
    # Total time ≈ 2s, not 3s

Scenario: Fire multiple independent I/O operations simultaneously (parallel API calls, parallel DB queries).

Note: A task that is created but never awaited will still run, but any exception it raises will be silently discarded. Always await your tasks or attach a add_done_callback.

3) `asyncio.Task` Methods#

1
async def main():
2
    task = asyncio.create_task(worker("A", 5.0))
3

4
    task.cancel()                    # Request cancellation
5
    print(task.done())               # True if finished/cancelled/errored
6
    print(task.cancelled())          # True if cancelled
7
    print(task.result())             # Returns result (raises if not done)
8
    task.add_done_callback(lambda t: print("finished:", t))

Method	Purpose
`cancel()`	Request cancellation — injects `CancelledError` at next `await`
`done()`	True if completed, cancelled, or raised an exception
`result()`	Returns the return value, or re-raises the exception
`exception()`	Returns the exception if one was raised, else `None`
`add_done_callback(fn)`	Register a callback to run when the task finishes

3. Concurrency Helpers (并发工具)#

1) `asyncio.gather(*coros, return_exceptions=False)`#

Runs multiple awaitables (可等待对象) concurrently, returns a list of results in the same order as input.

1
async def main():
2
    results = await asyncio.gather(
3
        fetch("url1"),
4
        fetch("url2"),
5
        fetch("url3"),
6
    )
7
    print(results)   # ["data from url1", "data from url2", "data from url3"]

With exception handling:

1
results = await asyncio.gather(
2
    fetch("url1"),
3
    failing_fetch(),
4
    return_exceptions=True   # Exceptions returned as values, not raised
5
)
6
for r in results:
7
    if isinstance(r, Exception):
8
        print(f"Error: {r}")

Scenario: Batch HTTP requests, parallel DB lookups, loading multiple config files simultaneously.

2) `asyncio.wait(tasks, return_when=...)`#

Returns two sets: done and pending. Gives fine-grained control over when to stop waiting.

1
async def main():
2
    tasks = {asyncio.create_task(fetch(url)) for url in urls}
3

4
    done, pending = await asyncio.wait(
5
        tasks,
6
        return_when=asyncio.FIRST_COMPLETED
7
    )
8
    for task in pending:
9
        task.cancel()

`return_when`	Behavior
`ALL_COMPLETED`	Wait for all tasks (default)
`FIRST_COMPLETED`	Return as soon as any task finishes
`FIRST_EXCEPTION`	Return as soon as any task raises

Scenario: Race condition (竞态) — take the first successful result and cancel the rest (e.g., querying multiple replicas, use whichever responds first).

3) `asyncio.as_completed(coros)`#

Yields tasks in completion order (not submission order).

1
async def main():
2
    coros = [fetch(url) for url in urls]
3
    for future in asyncio.as_completed(coros):
4
        result = await future
5
        print(f"Got: {result}")   # Processed as each one finishes

Scenario: Show results to the user as they arrive, without waiting for the slowest request.

4) `asyncio.TaskGroup` (Python 3.11+) — Structured Concurrency (结构化并发)#

If any task raises, all remaining tasks are automatically cancelled.

1
async def main():
2
    async with asyncio.TaskGroup() as tg:
3
        t1 = tg.create_task(fetch("url1"))
4
        t2 = tg.create_task(fetch("url2"))
5
    # All done here — or all cancelled if one failed
6
    print(t1.result(), t2.result())

Scenario: Any workflow where subtasks are all required — if one fails, the whole group should abort (e.g., a multi-step pipeline).

4. Timeouts & Cancellation (超时与取消)#

1) `asyncio.wait_for(coro, timeout)`#

1
async def main():
2
    try:
3
        result = await asyncio.wait_for(fetch("url"), timeout=3.0)
4
    except asyncio.TimeoutError:
5
        print("Request timed out after 3s")

Scenario: Any network call that must complete within a deadline (SLA enforcement, user-facing APIs).

2) `asyncio.timeout(seconds)` (Python 3.11+)#

A context-manager (上下文管理器) version of timeout — more composable than wait_for.

1
async def main():
2
    try:
3
        async with asyncio.timeout(5.0):
4
            result = await fetch("url")
5
            await process(result)
6
    except TimeoutError:
7
        print("Entire block timed out")

Scenario: Apply a single deadline across multiple awaits inside a block.

3) `asyncio.shield(coro)` — Protect from Cancellation#

Prevents the inner coroutine from being cancelled when the outer task is cancelled.

1
async def important_cleanup():
2
    await asyncio.sleep(1)
3
    print("Cleanup done")
4

5
async def main():
6
    task = asyncio.create_task(important_cleanup())
7
    try:
8
        await asyncio.shield(task)
9
    except asyncio.CancelledError:
10
        print("Outer cancelled, but cleanup still runs!")
11
        await task   # Wait for it to actually finish

Scenario: Protect a critical cleanup/commit operation from being interrupted by a cancellation signal.

4) Handling `CancelledError`#

1
async def worker():
2
    try:
3
        while True:
4
            await asyncio.sleep(1)
5
    except asyncio.CancelledError:
6
        print("Cleaning up before cancel...")
7
        await do_cleanup()
8
        raise   # Always re-raise!

Note: Always re-raise CancelledError after cleanup. Swallowing it breaks the cancellation chain. In Python 3.8+, CancelledError is a subclass of BaseException, not Exception.

5. Synchronization Primitives (同步原语)#

1) `asyncio.Lock` — Mutual Exclusion (互斥锁)#

1
lock = asyncio.Lock()
2

3
async def safe_write(db, data):
4
    async with lock:
5
        await db.write(data)   # Only one coroutine at a time

Scenario: Protecting shared in-memory state (counters, caches, connection pools) from concurrent modification.

2) `asyncio.Semaphore` — Concurrency Limiter (并发限制)#

1
sem = asyncio.Semaphore(10)   # Max 10 concurrent requests
2

3
async def rate_limited_fetch(session, url):
4
    async with sem:
5
        return await session.get(url)
6

7
async def main():
8
    async with aiohttp.ClientSession() as session:
9
        tasks = [rate_limited_fetch(session, url) for url in urls]
10
        results = await asyncio.gather(*tasks)

Scenario: Rate-limiting API calls, capping DB connection count, controlling concurrent file handles.

3) `asyncio.BoundedSemaphore`#

Same as Semaphore but raises ValueError if release() is called more times than acquire().

Scenario: Safety-critical resource pools where over-releasing would be a bug.

4) `asyncio.Event` — Signal Between Coroutines (协程间信号)#

1
event = asyncio.Event()
2

3
async def producer():
4
    await asyncio.sleep(2)
5
    print("Data ready")
6
    event.set()            # Signal the consumer
7

8
async def consumer():
9
    await event.wait()     # Block until set
10
    print("Processing data")
11

12
async def main():
13
    await asyncio.gather(producer(), consumer())

Scenario: One-shot notification — signal consumers when data/resource becomes available.

5) `asyncio.Condition` — Wait + Notify Pattern#

1
condition = asyncio.Condition()
2
buffer = []
3

4
async def producer():
5
    async with condition:
6
        buffer.append("item")
7
        condition.notify_all()   # Wake all waiting consumers
8

9
async def consumer():
10
    async with condition:
11
        await condition.wait_for(lambda: len(buffer) > 0)
12
        item = buffer.pop()

Scenario: Multiple consumers waiting on a shared resource to reach a specific state.

6) `asyncio.Queue` — Producer-Consumer (生产者-消费者)#

1
async def producer(q: asyncio.Queue):
2
    for i in range(10):
3
        await q.put(i)
4
    await q.put(None)   # Sentinel
5

6
async def consumer(q: asyncio.Queue):
7
    while True:
8
        item = await q.get()
9
        if item is None:
10
            break
11
        await process(item)
12
        q.task_done()
13

14
async def main():
15
    q = asyncio.Queue(maxsize=5)
16
    await asyncio.gather(producer(q), consumer(q))

Queue Type	Behavior
`Queue`	FIFO (先进先出)
`LifoQueue`	LIFO / stack (后进先出)
`PriorityQueue`	Smallest item dequeued first (优先队列)

Scenario: Pipeline architectures — web crawlers, log processors, streaming data ingestion.

6. Async Context Managers & Iterators (异步上下文管理器与迭代器)#

1) `async with` — Async Context Manager (异步上下文管理器)#

Implement aenter and aexit:

1
class AsyncDB:
2
    async def __aenter__(self):
3
        self.conn = await connect_db()
4
        return self.conn
5

6
    async def __aexit__(self, *args):
7
        await self.conn.close()
8

9
async def main():
10
    async with AsyncDB() as conn:
11
        result = await conn.query("SELECT 1")

Scenario: Any resource requiring async setup/teardown — DB connections, HTTP sessions, file handles, locks.

2) `@asynccontextmanager` — Decorator Shortcut#

1
from contextlib import asynccontextmanager
2

3
@asynccontextmanager
4
async def managed_connection():
5
    conn = await connect_db()
6
    try:
7
        yield conn
8
    finally:
9
        await conn.close()
10

11
async def main():
12
    async with managed_connection() as conn:
13
        await conn.query("SELECT 1")

Scenario: Simpler alternative to writing a full class when you need a one-off async context manager.

3) `async for` — Async Iterator (异步迭代器)#

Implement aiter and anext, or use an async generator:

1
async def paginated_api(base_url: str):
2
    page = 1
3
    while True:
4
        data = await fetch(f"{base_url}?page={page}")
5
        if not data:
6
            break
7
        yield data
8
        page += 1
9

10
async def main():
11
    async for page in paginated_api("https://api.example.com/items"):
12
        await process(page)

Scenario: Paginated APIs, streaming database cursors, real-time event streams (WebSocket, SSE).

7. Running Blocking Code (在异步中运行阻塞代码)#

1) `asyncio.to_thread(func, *args)` (Python 3.9+)#

1
import time
2

3
async def main():
4
    # Run blocking I/O in a thread without freezing the event loop
5
    result = await asyncio.to_thread(time.sleep, 2)

Scenario: Legacy blocking libraries (e.g., requests, psycopg2, time.sleep), file system operations.

2) `loop.run_in_executor(executor, func, *args)`#

1
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
2

3
async def main():
4
    loop = asyncio.get_running_loop()
5

6
    # Thread pool — for blocking I/O
7
    result = await loop.run_in_executor(None, blocking_io_func, arg)
8

9
    # Process pool — for CPU-bound work
10
    with ProcessPoolExecutor() as pool:
11
        result = await loop.run_in_executor(pool, cpu_bound_func, arg)

Executor	Use Case
`None` (default ThreadPool)	Blocking I/O, legacy libraries
`ThreadPoolExecutor`	Explicit thread pool sizing
`ProcessPoolExecutor`	CPU-bound tasks (bypasses GIL)

Scenario: Image processing, ML inference on CPU, compression, encryption — any heavy computation alongside async I/O.

8. Streams — High-Level Network I/O (高层网络 I/O)#

1) `asyncio.open_connection(host, port)` — TCP Client#

1
async def tcp_client():
2
    reader, writer = await asyncio.open_connection("127.0.0.1", 8888)
3

4
    writer.write(b"Hello\n")
5
    await writer.drain()
6

7
    data = await reader.readline()
8
    print(f"Received: {data.decode()}")
9

10
    writer.close()
11
    await writer.wait_closed()

Scenario: Custom TCP clients — talking to Redis, custom protocols, game servers.

2) `asyncio.start_server(handler, host, port)` — TCP Server#

1
async def handle_client(reader, writer):
2
    data = await reader.read(1024)
3
    writer.write(data)         # Echo back
4
    await writer.drain()
5
    writer.close()
6

7
async def main():
8
    server = await asyncio.start_server(handle_client, "127.0.0.1", 8888)
9
    async with server:
10
        await server.serve_forever()

Scenario: Building lightweight TCP/protocol servers (chat, telnet, custom RPC).

9. Subprocesses (异步子进程)#

1) `asyncio.create_subprocess_exec()` / `asyncio.create_subprocess_shell()`#

1
async def run_command():
2
    proc = await asyncio.create_subprocess_exec(
3
        "ls", "-la",
4
        stdout=asyncio.subprocess.PIPE,
5
        stderr=asyncio.subprocess.PIPE,
6
    )
7
    stdout, stderr = await proc.communicate()
8
    print(stdout.decode())
9

10
async def run_shell():
11
    proc = await asyncio.create_subprocess_shell(
12
        "echo hello && sleep 1 && echo world",
13
        stdout=asyncio.subprocess.PIPE,
14
    )
15
    stdout, _ = await proc.communicate()
16
    print(stdout.decode())

API	Use Case
`create_subprocess_exec`	Safe — no shell injection, explicit args
`create_subprocess_shell`	Convenient — supports pipes/redirects, shell expansion

Scenario: Running external tools (ffmpeg, git, compilers) without blocking the event loop.

10. Utilities & Introspection (工具与内省)#

1) `asyncio.sleep(delay, result=None)`#

1
async def main():
2
    await asyncio.sleep(0)    # Yield control without waiting (common pattern)
3
    await asyncio.sleep(1.5)  # Wait 1.5 seconds
4
    val = await asyncio.sleep(2, result="done")  # Returns result after delay
5
    print(val)   # "done"

Scenario: sleep(0) is used to yield control voluntarily in tight loops, preventing event loop starvation (事件循环饥饿).

2) `asyncio.current_task()` / `asyncio.all_tasks()`#

1
async def main():
2
    me = asyncio.current_task()
3
    me.set_name("main-task")
4

5
    all_running = asyncio.all_tasks()
6
    print(f"Running tasks: {len(all_running)}")

Scenario: Debugging, logging task names, graceful shutdown (cancel all tasks on SIGINT).

3) `asyncio.ensure_future(coro_or_future)`#

Schedules a coroutine or wraps a Future (期约) into a Task. Largely superseded by create_task() in modern code.

1
task = asyncio.ensure_future(my_coro())   # Legacy — prefer create_task()

4) `asyncio.wrap_future(future)` — Bridge with `concurrent.futures`#

Wraps a concurrent.futures.Future into an asyncio-compatible asyncio.Future.

1
import concurrent.futures
2

3
def blocking():
4
    return 42
5

6
async def main():
7
    loop = asyncio.get_running_loop()
8
    with concurrent.futures.ThreadPoolExecutor() as pool:
9
        future = pool.submit(blocking)
10
        result = await asyncio.wrap_future(future)
11
        print(result)   # 42

Scenario: Integrating existing concurrent.futures-based code into an asyncio application.

5) `asyncio.isfuture()` / `asyncio.iscoroutine()` / `asyncio.iscoroutinefunction()`#

1
import asyncio
2

3
async def my_coro(): pass
4

5
print(asyncio.iscoroutinefunction(my_coro))   # True
6
print(asyncio.iscoroutine(my_coro()))         # True
7
print(asyncio.isfuture(asyncio.Future()))     # True

Scenario: Writing framework code or decorators that need to handle both sync and async callables.

11. Low-level Event Loop APIs (底层事件循环接口)#

1) `loop.call_soon(callback, *args)` / `loop.call_later(delay, callback)`#

Schedule a plain (non-coroutine) callback:

1
loop = asyncio.get_event_loop()
2
loop.call_soon(print, "scheduled immediately")
3
loop.call_later(2.0, print, "scheduled in 2s")
4
loop.call_at(loop.time() + 5.0, print, "scheduled at absolute time")

Scenario: Integrating callback-based legacy code into an asyncio event loop.

2) `loop.add_reader(fd, callback)` / `loop.add_writer(fd, callback)`#

1
loop.add_reader(sock.fileno(), on_data_received)
2
loop.remove_reader(sock.fileno())

Scenario: Building low-level protocol handlers — custom socket management, raw I/O multiplexing.

3) `asyncio.Protocol` / `asyncio.DatagramProtocol`#

The low-level callback-based protocol interface, underlying StreamReader/StreamWriter.

1
class EchoProtocol(asyncio.Protocol):
2
    def connection_made(self, transport):
3
        self.transport = transport
4

5
    def data_received(self, data: bytes):
6
        self.transport.write(data)   # Echo
7

8
    def connection_lost(self, exc):
9
        print("Connection closed")
10

11
async def main():
12
    loop = asyncio.get_running_loop()
13
    server = await loop.create_server(EchoProtocol, "127.0.0.1", 8888)
14
    async with server:
15
        await server.serve_forever()

Scenario: High-performance servers where the overhead of StreamReader/StreamWriter is unacceptable, or when implementing a custom protocol (e.g., custom binary framing).

12. Graceful Shutdown Pattern (优雅关闭模式)#

1
import asyncio
2
import signal
3

4
async def main():
5
    loop = asyncio.get_running_loop()
6

7
    stop = loop.create_future()
8
    loop.add_signal_handler(signal.SIGINT, stop.set_result, None)
9
    loop.add_signal_handler(signal.SIGTERM, stop.set_result, None)
10

11
    tasks = [asyncio.create_task(worker(i)) for i in range(5)]
12

13
    await stop   # Block until SIGINT/SIGTERM
14

15
    print("Shutting down...")
16
    for t in tasks:
17
        t.cancel()
18

19
    await asyncio.gather(*tasks, return_exceptions=True)
20
    print("All tasks cancelled. Bye.")
21

22
asyncio.run(main())

Scenario: Any long-running async service (web server, bot, background processor) that must clean up gracefully on Ctrl+C or a system signal.

13. Quick API Comparison Table#

API	Category	Key Trait
`asyncio.run()`	Entry point	Creates + closes loop; top-level only
`create_task()`	Scheduling	Non-blocking schedule; returns Task
`gather()`	Concurrency	All results in order; short-circuits on exception
`wait()`	Concurrency	Returns done/pending sets; fine control
`as_completed()`	Concurrency	Yields in completion order
`TaskGroup`	Structured	Auto-cancel on failure (3.11+)
`wait_for()`	Timeout	Cancels task on timeout
`timeout()`	Timeout	Context manager; covers multiple awaits (3.11+)
`shield()`	Cancellation	Protects inner task from outer cancel
`Lock`	Sync	Mutex; one at a time
`Semaphore`	Sync	N at a time; rate limiting
`Event`	Sync	One-shot signal
`Condition`	Sync	Wait-for-state with notify
`Queue`	Sync	FIFO producer-consumer
`to_thread()`	Blocking	Offload to thread pool (3.9+)
`run_in_executor()`	Blocking	Thread or process pool
`open_connection()`	Streams	High-level TCP client
`start_server()`	Streams	High-level TCP server
`Protocol`	Low-level	Callback-based; max performance

💡 One-line Takeaway
Master the three tiers: use gather / TaskGroup for everyday concurrency, Lock / Semaphore / Queue for coordination, and to_thread / run_in_executor to escape blocking code — everything else (streams, protocols, signals) builds on these foundations.

I. Python asyncio — Principles & Core Mechanics#

1. How asyncio Works — The Big Picture#

2. Event Loop (事件循环)#

1) What the Event Loop Does#

2) Starting the Event Loop#

3. Coroutines (协程)#

1) What Is a Coroutine?#

2) How to Define and Use Coroutines#

II. Python asyncio — Complete API Reference & Usage Scenarios#

1. Entry Points — Running Coroutines#

1) asyncio.run(coro)#

2) asyncio.get_event_loop() / asyncio.get_running_loop()#

2. Coroutines & Tasks (协程与任务)#

1) async def / await — Defining and Awaiting Coroutines#

2) asyncio.create_task(coro) — Schedule Concurrently#

3) asyncio.Task Methods#

3. Concurrency Helpers (并发工具)#

1) asyncio.gather(*coros, return_exceptions=False)#

2) asyncio.wait(tasks, return_when=...)#

3) asyncio.as_completed(coros)#

4) asyncio.TaskGroup (Python 3.11+) — Structured Concurrency (结构化并发)#

4. Timeouts & Cancellation (超时与取消)#

1) asyncio.wait_for(coro, timeout)#

2) asyncio.timeout(seconds) (Python 3.11+)#

3) asyncio.shield(coro) — Protect from Cancellation#

4) Handling CancelledError#

5. Synchronization Primitives (同步原语)#

1) asyncio.Lock — Mutual Exclusion (互斥锁)#

2) asyncio.Semaphore — Concurrency Limiter (并发限制)#

3) asyncio.BoundedSemaphore#

4) asyncio.Event — Signal Between Coroutines (协程间信号)#

5) asyncio.Condition — Wait + Notify Pattern#

6) asyncio.Queue — Producer-Consumer (生产者-消费者)#