Adakah menggunakan `concurrent.futures.ThreadPoolExecutor` dalam titik akhir FastAPI berisiko?

Adakah Berisiko Menggunakan Concurrent.futures.ThreadPoolExecutor dalam Titik Akhir FastAPI?

Pernyataan Masalah:

Dalam kod ujian yang disediakan, ThreadPoolExecutor digunakan untuk mendapatkan semula data daripada berbilang tapak web secara serentak. Kebimbangannya ialah menggunakan pendekatan ini dalam titik akhir FastAPI boleh menyebabkan penciptaan benang yang berlebihan dan potensi isu seperti kebuluran sumber dan ranap aplikasi.

Kebimbangan dan Potensi Gotchas:

• Kehabisan Benang: Mencipta terlalu banyak benang boleh menghabiskan kumpulan benang sistem, yang membawa kepada kebuluran benang dan berkemungkinan ranap aplikasi atau hos.
• Pertentangan Sumber: Benang bersaing untuk mendapatkan sumber sistem, seperti memori dan CPU, yang boleh melambatkan aplikasi dan memberi kesan kepada prestasi.
• Kebolehsegerakan: Menguruskan penyegerakan antara utas dalam persekitaran berbilang benang boleh menjadi rumit dan memperkenalkan potensi untuk keadaan perlumbaan.

Penyelesaian Disyorkan: Menggunakan Perpustakaan HTTPX

Daripada menggunakan ThreadPoolExecutor, adalah dinasihatkan untuk menggunakan perpustakaan HTTPX, yang menawarkan API tak segerak. HTTPX menyediakan beberapa kelebihan:

• Kendalian Asynchronous: HTTPX berfungsi secara tidak segerak, membolehkan pengendalian permintaan serentak yang cekap tanpa menyekat kumpulan benang.
• Pengurusan Kolam Sambungan: Ia mengurus kumpulan sambungan secara automatik, memastikan sambungan digunakan semula dan mengehadkan bilangan sambungan aktif.
• Kawalan Berbutir Halus: HTTPX membenarkan penyesuaian had sambungan dan tamat masa, memberikan kawalan tepat ke atas penggunaan sumber.
• Penyepaduan Ringkas dengan FastAPI: FastAPI boleh disepadukan dengan HTTPX dengan lancar, menggunakan sokongan async yang disediakan oleh rangka kerja.

Contoh Berfungsi:

from fastapi import FastAPI, Request
from contextlib import asynccontextmanager
import httpx
import asyncio

URLS = ['https://www.foxnews.com/',
        'https://edition.cnn.com/',
        'https://www.nbcnews.com/',
        'https://www.bbc.co.uk/',
        'https://www.reuters.com/']

@asynccontextmanager
async def lifespan(app: FastAPI):
    # Customise settings
    limits = httpx.Limits(max_keepalive_connections=5, max_connections=10)
    timeout = httpx.Timeout(5.0, read=15.0)  # 5s timeout on all operations

    # Initialise the Client on startup and add it to the state
    async with httpx.AsyncClient(limits=limits, timeout=timeout) as client:
        yield {'client': client}
        # The Client closes on shutdown

app = FastAPI(lifespan=lifespan)

async def send(url, client):
    return await client.get(url)

@app.get('/')
async def main(request: Request):
    client = request.state.client
    tasks = [send(url, client) for url in URLS]
    responses = await asyncio.gather(*tasks)
    return [r.text[:50] for r in responses]  # For demo purposes, only return the first 50 chars of each response

Coretan kod ini menunjukkan penggunaan HTTPX dengan FastAPI untuk mengendalikan permintaan serentak secara tidak segerak, dengan berkesan mengurangkan kebimbangan yang berkaitan dengan keletihan benang dan pertikaian sumber.

Atas ialah kandungan terperinci Adakah menggunakan `concurrent.futures.ThreadPoolExecutor` dalam titik akhir FastAPI berisiko?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!