36. Coroutine và Async

Coroutine là các phép tính có thể tiếp tục được sử dụng cho lập trình không đồng bộ. Họ để mã Python tạm dừng ở mứcawaitđiểm, đưa điều khiển trở lại vòng lặp sự kiện và sau đó tiếp tục lại khi thao tác được chờ đợi có kết quả.

Một coroutine tương tự như một trình tạo vì cả hai đều duy trì trạng thái thực thi trong suốt quá trình tạm ngưng. Sự khác biệt là giao thức và mục đích.

Trình tạo mang lại giá trị cho người tiêu dùng vòng lặp.

Một coroutine chờ các hoạt động không đồng bộ khác và cuối cùng trả về một kết quả cuối cùng.python id="o2u8bi" async def fetch(): data = await read() return data Đang gọifetch()không chạy cơ thể để hoàn thành. Nó tạo ra một đối tượng coroutine.```python id="9i5ai1" coro = fetch()

## 36.1 Hàm Coroutine vs Đối tượng Coroutine

Một`async def`câu lệnh tạo ra một hàm coroutine.

Việc gọi hàm coroutine sẽ tạo ra một đối tượng coroutine.```python id="rt8ky9"
async def work():
    return 42

coro = work()
```Về mặt khái niệm:```text id="q71j65"
work
    coroutine function object

work()
    coroutine object
        suspended execution state
        code object
        frame or frame-like state
```Điều này khác với một chức năng thông thường:```python id="nv1t8j"
def work():
    return 42

work()
```Một lệnh gọi hàm thông thường sẽ chạy ngay lập tức và trả về`42`.

Lệnh gọi hàm không đồng bộ trả về một đối tượng coroutine mà sau này phải được điều khiển.

## 36,2`await`

`await`tạm dừng coroutine hiện tại cho đến khi một coroutine khác có thể chờ đợi hoàn tất.```python id="wjue72"
async def outer():
    value = await inner()
    return value + 1
```Biểu thức:```python id="pbwts5"
await inner()
```thực hiện một số điều về mặt khái niệm:```text id="n2ycfi"
call inner()
obtain awaitable object
suspend current coroutine
let event loop drive awaitable
resume current coroutine with result
```Nếu hoạt động được chờ đợi tăng lên, ngoại lệ sẽ được đưa trở lại vào coroutine đang chờ.```python id="yc56f3"
async def outer():
    try:
        value = await inner()
    except ValueError:
        value = 0
    return value
```## 36.3 Đang chờ`await`hoạt động trên các đối tượng được chờ đợi.

Những thứ được chờ đợi phổ biến bao gồm:```text id="o2vwvk"
coroutine objects
asyncio Task objects
asyncio Future objects
objects implementing __await__
```Một đối tượng tùy chỉnh có thể được chờ đợi bằng cách xác định`__await__`.

```python id="f4sd9q"
class Immediate:
    def __await__(self):
        yield
        return 42
```Trong thực tế, hầu hết mã ứng dụng đều chờ coroutine, nhiệm vụ và tương lai được tạo bởi khung không đồng bộ.

## 36.4 Trạng thái coroutine

Một coroutine có thể ở các trạng thái tương tự như trạng thái của trình tạo:```text id="qcur3i"
created
running
suspended
closed
```Sử dụng`inspect`:

```python id="84zov8"
import inspect

async def work():
    await other()

coro = work()
print(inspect.getcoroutinestate(coro))
```Các trạng thái phổ biến bao gồm:```text id="h0yb3u"
CORO_CREATED
CORO_RUNNING
CORO_SUSPENDED
CORO_CLOSED
```Nhiều người tiêu dùng không thể chờ đợi một coroutine cùng một lúc. Nó đại diện cho một lần thực hiện.

## 36.5 Khung Coroutine

Một coroutine bị đình chỉ sẽ giữ trạng thái thực thi của nó.

Trạng thái đó bao gồm:```text id="o61wj7"
code object
instruction position
local variables
value stack
exception state
currently awaited object
running state
closed state
```Ví dụ:```python id="1tow3u"
async def process():
    data = await read()
    return transform(data)
```Trong khi bị đình chỉ tại`await read()`, coroutine phải nhớ:```text id="985lzm"
current frame
local variables
await target
next instruction after await
```Khi`read()`hoàn tất, coroutine sẽ tiếp tục và gán giá trị trả về cho`data`.

## 36.6 Coroutine sử dụng cùng một Frame Model

Coroutine không sử dụng trình thông dịch riêng. Chúng được thực thi bởi cùng một vòng đánh giá CPython.

Vòng lặp chạy cho đến coroutine:```text id="p7w1wv"
awaits and suspends
returns
raises
is cancelled
```Về mặt khái niệm:```text id="xzr16h"
coroutine object
    frame state
        bytecode
        stack
        locals

event loop
    resumes coroutine
        evaluation loop runs frame
        stops at await or completion
```Vòng lặp sự kiện thực hiện lập lịch trình. CPython cung cấp bộ máy thực thi có thể tiếp tục.

## 36.7 Vòng lặp sự kiện

Vòng lặp sự kiện điều phối các tác vụ không đồng bộ.

TRONG`asyncio`, vòng lặp sự kiện quản lý:```text id="n7xdfh"
ready tasks
sleep timers
socket readiness
future completion
callbacks
cancellation
exception reporting
```Ví dụ:```python id="0chlb7"
import asyncio

async def main():
    await asyncio.sleep(1)
    return 42

result = asyncio.run(main())
print(result)

asyncio.runtạo và điều khiển một vòng lặp sự kiện cho đến khimain()hoàn thành.

Bản thân CPython cung cấp các đối tượng coroutine vàawaitngữ nghĩa.asynciocung cấp một triển khai vòng lặp sự kiện tiêu chuẩn.

36.8 Nhiệm vụ

Riêng đối tượng coroutine là thụ động. Một tác vụ lên lịch cho nó thực hiện.```python id="8et1tq" import asyncio

async def work(): await asyncio.sleep(1) return 42

async def main(): task = asyncio.create_task(work()) result = await task return result Về mặt khái niệm:text id="p93t67" coroutine object passive resumable computation

task event-loop managed wrapper resumes coroutine stores result or exception supports cancellation

## 36.9 Hợp tác đồng thời

Async Python sử dụng đồng thời hợp tác.

Một coroutine chạy cho đến khi đạt đến điểm chờ.```python id="8ux1ur"
async def work():
    step1()
    await wait()
    step2()
```Trong lúc`step1()`, không có tác vụ nào khác chạy trên vòng lặp sự kiện đó trừ khi`step1()`chính nó đang chờ hoặc trả lại quyền điều khiển.

Tại`await wait()`, coroutine tạm dừng và vòng lặp sự kiện có thể chạy một tác vụ khác.

Điều này có nghĩa là mã nặng CPU bên trong coroutine có thể chặn vòng lặp sự kiện:```python id="g8fwp9"
async def bad():
    while True:
        compute()
```Không có`await`, coroutine này không mang lại quyền kiểm soát.

## 36.10 Async không phải là tính song song

Đồng thời không đồng bộ không tự động có nghĩa là song song CPU.

Một vòng lặp sự kiện thường chạy trong một luồng hệ điều hành. Nó chỉ chuyển đổi giữa các nhiệm vụ tại các điểm treo.

Async hoạt động tốt cho:```text id="oell4m"
network I/O
many open connections
timeouts
sleeping
waiting for subprocesses
streaming protocols
cooperative task orchestration
```Nó không làm cho mã byte Python gắn với CPU chạy song song.

Đối với công việc liên quan đến CPU, hãy sử dụng:```text id="r5575k"
native extensions
multiprocessing
process pools
thread pools for blocking calls
free-threaded builds where appropriate
external workers
```## 36.11 Đang chờ Coroutine

Cho:```python id="h5auqh"
async def inner():
    return 10

async def outer():
    x = await inner()
    return x + 1
```Dòng chảy là:```text id="fi924o"
outer starts
outer calls inner(), producing inner coroutine
outer awaits inner coroutine
event loop drives inner
inner returns 10
outer resumes with x = 10
outer returns 11
```Giá trị trả về vượt qua ranh giới chờ đợi trở lại khung bị treo.

##36.12 Chờ đợi một tương lai

Tương lai đại diện cho một kết quả có thể chưa tồn tại.```python id="6xf2w8"
future = loop.create_future()
```Một coroutine có thể chờ đợi nó:```python id="qze0h0"
value = await future
```Nếu tương lai chưa hoàn tất, coroutine sẽ tạm dừng.

Sau đó:```python id="nrkg2x"
future.set_result(42)
```Vòng lặp sự kiện đánh dấu các nhiệm vụ đang chờ sẵn sàng. Coroutine đang chờ tiếp tục với`42`.

Nếu tương lai có ngoại lệ:```python id="xzr05h"
future.set_exception(ValueError("bad"))
```coroutine đang chờ sẽ tiếp tục bằng cách đưa ra ngoại lệ đó tại điểm chờ.

## 36.13 Đang chờ nhiệm vụ

Một nhiệm vụ cũng được chờ đợi.```python id="w7s6x8"
task = asyncio.create_task(work())
result = await task
```Nếu nhiệm vụ kết thúc bình thường,`await task`trả về kết quả của nó.

Nếu nhiệm vụ tăng lên,`await task`đưa ra ngoại lệ tương tự.

Nếu nhiệm vụ bị hủy bỏ,`await task`tăng lên`CancelledError`.

## 36.14 Hủy bỏ

Việc hủy yêu cầu một tác vụ phải dừng lại.```python id="j5ce0q"
task.cancel()
```TRONG`asyncio`, việc hủy bỏ được thực hiện bằng cách tiêm`CancelledError`vào coroutine tại một điểm chờ.```python id="lczbrw"
async def work():
    try:
        await asyncio.sleep(10)
    except asyncio.CancelledError:
        cleanup()
        raise
```Một coroutine có thể bắt được lệnh hủy để dọn dẹp, nhưng nó thường phải khởi động lại trừ khi nó cố ý ngăn chặn việc hủy.

Việc hủy bỏ là hợp tác. Một coroutine không bao giờ chờ đợi có thể không quan sát thấy việc hủy kịp thời.

## 36.15 Dọn dẹp bằng`try/finally`Sử dụng`try/finally`để dọn dẹp không đồng bộ.```python id="j83mx6"
async def work():
    resource = await acquire()
    try:
        await use(resource)
    finally:
        await release(resource)
```các`finally`khối chạy trên:```text id="m2ocv7"
normal completion
exception
cancellation
```Nếu quá trình dọn dẹp đang chờ xử lý thì coroutine có thể tạm dừng trong quá trình dọn dẹp.

Điều này làm cho việc hủy bỏ và dọn dẹp trở nên tinh tế. Coroutine có thể ở trạng thái bị hủy trong khi vẫn thực thi mã quyết toán.

## 36.16 Trình quản lý bối cảnh không đồng bộ

Trình quản lý bối cảnh không đồng bộ sử dụng`async with`.

```python id="v2e2wy"
async with lock:
    await work()
```Đối tượng phải cung cấp:```text id="5scc5n"
__aenter__
__aexit__
```Về mặt khái niệm:```python id="dkm7oc"
mgr = lock
value = await mgr.__aenter__()
try:
    await work()
except BaseException as exc:
    suppress = await mgr.__aexit__(type(exc), exc, exc.__traceback__)
    if not suppress:
        raise
else:
    await mgr.__aexit__(None, None, None)
```Trình quản lý bối cảnh không đồng bộ cho phép tạm dừng thu thập và phát hành tài nguyên.

## 36.17 Trình lặp không đồng bộ

Sử dụng lặp lại không đồng bộ`async for`.

```python id="hvh27p"
async for item in stream:
    process(item)
```Đối tượng phải cung cấp:```text id="u37g80"
__aiter__
__anext__
```Về mặt khái niệm:```python id="z1gd9g"
ait = stream.__aiter__()

while True:
    try:
        item = await ait.__anext__()
    except StopAsyncIteration:
        break
    process(item)
```Lặp lại không đồng bộ rất hữu ích cho các luồng trong đó mỗi mục tiếp theo có thể yêu cầu I/O.

## 36.18 Trình tạo không đồng bộ

Trình tạo không đồng bộ được xác định bằng`async def`Và`yield`.

```python id="65vpyy"
async def lines(reader):
    async for line in reader:
        yield line.strip()
```Nó tạo ra một trình vòng lặp không đồng bộ.

Sử dụng:```python id="5lhj9g"
async for line in lines(reader):
    print(line)
```Trình tạo Async có thể vừa chờ vừa mang lại kết quả.```python id="8c9u5e"
async def gen():
    await asyncio.sleep(1)
    yield 1
```Họ kết hợp hệ thống treo coroutine với việc tạo ra giá trị theo kiểu máy phát điện.

## 36,19`anext`

`anext`lấy mục tiếp theo từ một trình vòng lặp không đồng bộ.```python id="vs0dl0"
item = await anext(ait)
```Điều này đang chờ đợi`ait.__anext__()`.

Nếu trình lặp async đã hết, nó sẽ tăng`StopAsyncIteration`.

Một mặc định có thể được cung cấp:```python id="8d97ug"
item = await anext(ait, default)
```## 36,20`StopAsyncIteration`Hoàn thành tín hiệu của trình vòng lặp không đồng bộ với`StopAsyncIteration`.

Điều này khác biệt với`StopIteration`.

```text id="prf78x"
normal iterator ends with StopIteration
async iterator ends with StopAsyncIteration

async forđánh bắtStopAsyncIterationđể thoát khỏi vòng lặp.

Nâng caoStopIterationtừ lần lặp không đồng bộ là không chính xác.

36.21 Mã byte Coroutine

Hàm async biên dịch thành một đối tượng mã được đánh dấu là mã coroutine.```python id="m36blp" async def f(): return 1

Một chức năng không đồng bộ với đang chờ:```python id="vb752s"
async def f():
    value = await g()
    return value
```về mặt khái niệm bao gồm mã byte cho:```text id="aw12fn"
call g
get awaitable iterator
send into awaitable
suspend if not done
resume with result
store value
return value
```Mã byte chính xác thay đổi theo phiên bản Python. Mô hình vẫn còn:`await`được triển khai dưới dạng thực thi khung có thể tiếp tục.

## 36,22`SEND`và chờ đợi

Mã byte CPython hiện đại sử dụng máy móc giống như gửi để điều khiển các sản phẩm đang chờ.

Về mặt khái niệm:```text id="c07p30"
await awaitable:
    get awaitable iterator
    send None or value
    if it yields:
        suspend current coroutine
    if it returns:
        resume with result
    if it raises:
        propagate exception
```Điều này liên quan đến ủy quyền của máy phát điện. Coroutine được xây dựng dựa trên ý tưởng tương tự là gửi giá trị vào các phép tính bị treo.

## 36.23 Trả về Coroutine

Một coroutine trả về một giá trị cuối cùng.```python id="11vkrn"
async def f():
    return 42
```Khi chờ đợi:```python id="q0irxd"
value = await f()
```coroutine đang chờ nhận được`42`.

Trong nội bộ, sự hoàn thành được thể hiện thông qua giao thức có thể chờ đợi. Ở cấp độ người dùng,`await`biến việc hoàn thành coroutine thành một kết quả biểu thức thông thường.

## 36.24 Ngoại lệ của Coroutine

Nếu một coroutine tăng lên, hãy chờ nó tăng lên.```python id="ufon8f"
async def f():
    raise ValueError("bad")

async def main():
    await f()
```Ngoại lệ lan truyền đến`main`tại điểm chờ.

Bạn có thể bắt nó:```python id="vi414s"
async def main():
    try:
        await f()
    except ValueError:
        return 0
```Truy nguyên bao gồm các khung coroutine liên quan đến chuỗi cuộc gọi không đồng bộ.

## 36.25 Cảnh báo về Coroutine

Việc tạo một coroutine và không bao giờ chờ đợi nó thường là một lỗi.```python id="j9rvzc"
async def f():
    return 1

f()
```Điều này tạo ra một đối tượng coroutine và loại bỏ nó.

Python có thể cảnh báo:```text id="e1rugz"
RuntimeWarning: coroutine was never awaited
```Cơ thể không bao giờ chạy.

Cách sử dụng đúng:```python id="5e8f4p"
await f()
```hoặc:```python id="daxsm1"
asyncio.create_task(f())
```## 36,26`asyncio.run`

`asyncio.run`là điểm vào tiêu chuẩn để chạy chức năng chính không đồng bộ.```python id="45lxp3"
import asyncio

async def main():
    await asyncio.sleep(1)
    return 42

print(asyncio.run(main()))
```Nó tạo một vòng lặp sự kiện, chạy coroutine cho đến khi hoàn thành, xử lý việc dọn dẹp trình tạo async cuối cùng và đóng vòng lặp.

Bạn thường gọi nó một lần ở cấp cao nhất của chương trình.

## 36.27 Chặn cuộc gọi bên trong mã Async

Chặn cuộc gọi sẽ dừng vòng lặp sự kiện.

Xấu:```python id="upggpj"
import time

async def main():
    time.sleep(5)
```Trong lúc`time.sleep`, vòng lặp sự kiện không thể chạy các tác vụ khác.

Tốt hơn:```python id="j76gyt"
import asyncio

async def main():
    await asyncio.sleep(5)
```Đối với các chức năng chặn không thể thực hiện không đồng bộ, hãy sử dụng trình thực thi hoặc trình trợ giúp luồng:```python id="bo70ck"
result = await asyncio.to_thread(blocking_function, arg)
```Điều này giữ cho vòng lặp sự kiện phản hồi nhanh.

## 36.28 Nhóm nhiệm vụ

Các nhiệm vụ liên quan đến nhóm đồng thời có cấu trúc.```python id="jrw68m"
import asyncio

async def main():
    async with asyncio.TaskGroup() as tg:
        tg.create_task(fetch_one())
        tg.create_task(fetch_two())
```Một nhóm nhiệm vụ chờ đợi các nhiệm vụ con của nó. Nếu một nhiệm vụ thất bại, nhóm sẽ điều phối việc hủy bỏ và đưa ra các ngoại lệ được nhóm nếu cần.

Điều này an toàn hơn việc tạo nhiệm vụ mà không theo dõi chúng.

## 36,29 Nhóm ngoại lệ trong mã Async

Nhiệm vụ đồng thời có thể thất bại cùng nhau.

Nhóm tác vụ có thể báo cáo nhiều lỗi bằng cách sử dụng các nhóm ngoại lệ.```python id="75j6zk"
try:
    async with asyncio.TaskGroup() as tg:
        tg.create_task(a())
        tg.create_task(b())
except* ValueError as group:
    handle_value_errors(group)