Why does ws.send_text("1") execute before load_dataset("beans") in FastAPI?

FastAPI asynchronous programming with await keywords: ws.send_text() and load_dataset() execution order

This article discusses the execution order of ws.send_text() and load_dataset() functions when using async / await for asynchronous programming in the FastAPI framework. In the previous code example, there was a misunderstanding: ws.send_text("1") seems to have to wait for load_dataset("beans") to complete before execution. In fact, this is not the case.

The key is to understand the role of the await keyword and the characteristics of load_dataset() function. await is only used to wait for the asynchronous operation to complete. ws.send_text() is an asynchronous operation, so await ws.send_text("1") will wait for the message to be sent to complete. However, load_dataset("beans") is a synchronous blocking operation that blocks the current coroutine until the dataset loads.

Code execution process analysis:

1. await ws.accept() : Wait for the WebSocket connection to be established.
2. await ws.send_text("1") : Send the message "1" asynchronously, and continue to execute after this operation is completed.
3. dataset = load_dataset("beans") : The synchronous blocking operation begins, the program pauses here until load_dataset("beans") downloads and loads the dataset from remotely and completes.
4. await ws.send_text("2") : Send the message "2" asynchronously, and you also need to wait for the sending to complete.

Experimental verification and interpretation of results:

The experimental results clearly show that the browser side receives "1" first, and then "2", which is consistent with the blocking characteristic of load_dataset("beans") . Although ws.send_text("1") is executed first, the blocking of load_dataset("beans") causes the sending of "2" to be delayed until the dataset is loaded.

Improved code to implement concurrency:

If load_dataset("beans") and ws.send_text("1") are required to execute concurrently, load_dataset("beans") needs to be transformed into asynchronous operations. This usually requires the use of asynchronous IO libraries, such as aiohttp , to download data. Here is an improved example (assuming that aiohttp is used and an asynchronous load_dataset_async function is implemented):

 import asyncio
from datetime import datetime

from datasets import load_dataset
from fastapi import FastAPI, WebSocket
from fastapi.responses import HTMLResponse

app = FastAPI()

# ... (HTML code remains the same) ...

@app.websocket("/ws")
async def h(ws: WebSocket):
    await ws.accept()
    task = asyncio.create_task(load_dataset_async("beans")) # Asynchronously load dataset
    await ws.send_text(f"1: {datetime.now()}")
    dataset = await task # Await the dataset loading task
    print(f"time: {datetime.now()} => dataset: {dataset}")
    await ws.send_text(f"2: {datetime.now()}")
    # ... (rest of the code remains the same) ...

Create asynchronous tasks through asyncio.create_task() , load_dataset_async("beans") can be executed concurrently in the background without blocking the main coroutine.

Summary: ws.send_text("1") was executed first in the original code, but the synchronous blocking feature of load_dataset("beans") determines the execution order of subsequent operations. To achieve concurrency, the data loading operation must be asynchronous.

The above is the detailed content of Why does ws.send_text("1") execute before load_dataset("beans") in FastAPI?. For more information, please follow other related articles on the PHP Chinese website!