0 dní v řadě · 0 bodů

Python pod kapotou · 35 min

asyncio

Jedno vlákno a stovky čekajících úloh. Korutiny, smyčka událostí, TaskGroup, limity, timeouty a co celý program nechtěně zastaví.

Hloubka
Úkoly
Lidsky řečeno

Na poště sedí jediná úřednice a před ní stojí fronta. Každému dá formulář: „Vyplňte si ho támhle u pultu a vraťte se.“ Zatímco lidé píšou, bere dalšího. Úřednice je pořád jedna, ale nikdy nesedí a nekouká do zdi. Přesně tak pracuje asyncio: jeden pracovník, hodně rozdělané práce a přepnutí vždy ve chvíli, kdy někdo stejně jen čeká.

Program, který mluví se sítí nebo databází, většinu času nic nedělá. Pošle dotaz a čeká na odpověď. V lekci o vláknech a procesech jsi čekání řešil dalšími vlákny. asyncio na to jde jinak: všechno běží v jednom vlákně a úlohy si předávají slovo samy, když narazí na čekání. Říká se tomu kooperativní přepínání, protože bez spolupráce úloh nefunguje.

SituaceCo zvolit
Stovky spojení, většinu času se čekáasyncio
Pár souběžných čekání a knihovny bez podpory asyncvlákna
Těžký výpočet na procesoruprocesy

Korutina: funkce, která umí odejít od přepážky

Funkce napsaná přes async def se jmenuje korutinová funkce. Když ji zavoláš, nic se neprovede. Dostaneš objekt korutina, tedy rozdělanou práci, která čeká, až ji někdo rozběhne.

Slovo await znamená: „tady čekám, mezitím ať běží někdo jiný“. Smí stát jen uvnitř async def.

V ukázce korutinu rozběhneme ručně metodou send(None). Ta ji pustí k nejbližšímu zastavení. Třída Pauza je to nejmenší, na co se dá čekat. Znáš ten princip z generátorů: yield předá řízení ven.

class Pauza:
    def __await__(self):
        yield "čekám"

async def uvar_caj(druh):
    print("dávám vařit vodu")
    await Pauza()
    print("zalévám:", druh)
    return f"šálek, {druh}"

korutina = uvar_caj("zelený")
print("zatím se nic nestalo:", type(korutina).__name__)

print("první send vrátil:", korutina.send(None))

try:
    korutina.send(None)
except StopIteration as konec:
    print("návratová hodnota:", konec.value)
Výstup
zatím se nic nestalo: coroutine
dávám vařit vodu
první send vrátil: čekám
zalévám: zelený
návratová hodnota: šálek, zelený

Když korutina doběhne, vyhodí StopIteration a v value nese to, co vrátil return. Nikde tu není žádná magie ani druhé vlákno. Je to funkce, která se umí zastavit uprostřed a později pokračovat.

Úkol

Doběhni korutinu

Napiš funkci dobehni(korutina). Opakovaně volá send(None), počítá zastavení a na konci vrátí dvojici (vysledek, pocet_pauz). Pro tri_kroky() tedy ("hotovo", 3).

class Pauza:
    def __await__(self):
        yield

async def tri_kroky():
    await Pauza()
    await Pauza()
    await Pauza()
    return "hotovo"

def dobehni(korutina):
    # doplň: send(None) ve smyčce, počítání pauz, zachycení StopIteration
    return None, 0

print(dobehni(tri_kroky()))
Výstup

Smyčka událostí

Něco musí rozhodovat, kdo je na řadě. Tomu se říká smyčka událostí (event loop). V jádru je to fronta: vezmi první úlohu, nech ji běžet do dalšího await, zařaď ji zpět a pokračuj další. Dá se to napsat na pár řádků.

from collections import deque

class Pauza:
    def __await__(self):
        yield

async def pracovnik(jmeno, kroku):
    for krok in range(1, kroku + 1):
        print(f"{jmeno}: krok {krok}")
        await Pauza()
    return f"{jmeno} končí"

def smycka(korutiny):
    fronta = deque(korutiny)
    while fronta:
        aktualni = fronta.popleft()
        try:
            aktualni.send(None)
        except StopIteration as konec:
            print("  ->", konec.value)
        else:
            fronta.append(aktualni)

smycka([pracovnik("A", 2), pracovnik("B", 3)])
Výstup
A: krok 1
B: krok 1
A: krok 2
B: krok 2
  -> A končí
B: krok 3
  -> B končí

Dvě úlohy se střídají, přestože běží jediné vlákno. Skutečné asyncio přidává časovače a sledování sítě, ale kostra je stejná.

Úkol

Vlastní plánovač

Napiš spust_vse(korutiny). Korutiny se střídají po jednom kroku jako ve smyčce výše a funkce vrátí seznam výsledků ve stejném pořadí, v jakém korutiny přišly, i když některá skončí dřív.

from collections import deque

class Pauza:
    def __await__(self):
        yield

async def pracovnik(jmeno, kroku):
    for _ in range(kroku):
        await Pauza()
    return jmeno

def spust_vse(korutiny):
    # doplň
    return []

print(spust_vse([pracovnik("a", 3), pracovnik("b", 0), pracovnik("c", 1)]))
Výstup
Kvíz

Jedna úloha začne počítat dlouhý cyklus a nemá v něm žádné await. Co dělají ostatní úlohy?

Pod kapotou · co dělá skutečná smyčka

Task je obal kolem korutiny a jeho krok volá coro.send(None) stejně jako náš plánovač. Když korutina čeká na Future, Future.__await__ vydá přes yield sám sebe. Hodnota proletí celým řetězcem await až do Task, který si na ni přes add_done_callback zaregistruje probuzení a skončí. Dokud Future nedoběhne, úloha není v žádné frontě, takže spící úlohy nestojí žádný čas procesoru.

Smyčka drží frontu připravených callbacků (_ready) a haldu časovačů (_scheduled). V každé otáčce spočítá timeout podle nejbližšího časovače a zavolá selektor: epoll na Linuxu, kqueue na BSD a macOS. Na Windows je výchozí ProactorEventLoop nad IOCP.

Důležitý důsledek: await na korutinu sám o sobě nepřepíná. Jen do ní vstoupí jako volání funkce. K přepnutí dojde až tehdy, když řetězec dojde k opravdovému čekání. Korutina, která v cyklu volá jiné korutiny bez skutečného I/O, smyčku vyhladoví. Explicitní předání řízení je await asyncio.sleep(0), což je v CPythonu holý yield. Základ popisují PEP 3156 a PEP 492.

asyncio.run a gather

Teď skutečná knihovna. asyncio.run(main()) vytvoří smyčku, spustí v ní korutinu, po jejím konci uklidí a smyčku zavře. Bývá v programu jednou, na nejvyšší úrovni.

asyncio.sleep(s) je čekání, které smyčku neblokuje. V praxi na jeho místě stojí síťový dotaz. asyncio.gather spustí několik věcí souběžně a počká na všechny.

Ukázky s asyncio.run spouštěj u sebe na počítači. Prohlížeč má vlastní smyčku a druhou v ní rozběhnout nejde.

import asyncio

async def stahni(nazev, sekundy):
    print("start", nazev)
    await asyncio.sleep(sekundy)
    print("konec", nazev)
    return nazev.upper()

async def po_jednom():
    return [await stahni("a", 0.2), await stahni("b", 0.1)]

async def naraz():
    return await asyncio.gather(stahni("a", 0.2), stahni("b", 0.1))

for varianta in (po_jednom, naraz):
    print("---", varianta.__name__)
    print(asyncio.run(varianta()))
Výstup
--- po_jednom
start a
konec a
start b
konec b
['A', 'B']
--- naraz
start a
start b
konec b
konec a
['A', 'B']

První varianta trvá součet obou čekání, druhá jen tolik co nejdelší z nich. Všimni si, že u naraz skončí b dřív, a přesto je ve výsledku A první: gather vrací hodnoty v pořadí, v jakém jsi je předal.

Kvíz

Kolik zhruba trvá await a() a hned po něm await b(), když každá korutina sekundu čeká přes asyncio.sleep(1)?

Úlohy a TaskGroup

asyncio.create_task naplánuje korutinu jako úlohu (task). Ta se rozběhne, jakmile se smyčka dostane ke slovu, a kód pokračuje dál. Výsledek si vyzvedneš přes await uloha.

import asyncio

async def pipni(text, za):
    await asyncio.sleep(za)
    print(text)
    return len(text)

async def main():
    uloha = asyncio.create_task(pipni("hlášení z pozadí", 0.05))
    print("main pokračuje, hotovo:", uloha.done())
    await asyncio.sleep(0.15)
    print("main se vrátil, hotovo:", uloha.done())
    print("výsledek:", await uloha)

asyncio.run(main())
Výstup
main pokračuje, hotovo: False
hlášení z pozadí
main se vrátil, hotovo: True
výsledek: 16

Co když jedna z více úloh selže? Od Pythonu 3.11 je na to asyncio.TaskGroup. Píše se s async with, což je obyčejné with, jehož vstup a výstup smějí čekat. Blok skončí, až doběhnou všechny úlohy. Když některá spadne, ostatní se zruší a chyby přijdou zabalené ve skupině, kterou chytíš přes except*.

import asyncio

async def nacti(nazev, za, selze=False):
    try:
        await asyncio.sleep(za)
        if selze:
            raise ValueError(f"{nazev}: vadná data")
        print(nazev, "hotovo")
        return nazev
    except asyncio.CancelledError:
        print(nazev, "zrušeno")
        raise

async def main():
    try:
        async with asyncio.TaskGroup() as skupina:
            rychla = skupina.create_task(nacti("rychlá", 0.05))
            skupina.create_task(nacti("vadná", 0.15, selze=True))
            pomala = skupina.create_task(nacti("pomalá", 5))
    except* ValueError as chyby:
        for chyba in chyby.exceptions:
            print("chyba:", chyba)
    print("rychlá vrátila:", rychla.result())
    print("pomalá zrušena:", pomala.cancelled())

asyncio.run(main())
Výstup
rychlá hotovo
pomalá zrušeno
chyba: vadná: vadná data
rychlá vrátila: rychlá
pomalá zrušena: True

Pomalá úloha by běžela pět sekund, ale program skončí hned po chybě. Nic nezůstane viset na pozadí.

Pod kapotou · gather, TaskGroup a zrušení

gather při chybě nic neruší. První výjimka doputuje k tomu, kdo čeká, ale ostatní úlohy běží dál bez dozoru. Parametr return_exceptions=True vrátí výjimky jako hodnoty. TaskGroup (structured concurrency, výjimkové skupiny z PEP 654) zaručí, že po opuštění bloku žádná jeho úloha neběží. V novém kódu je to rozumná výchozí volba.

Slabé reference. Smyčka si drží na úlohy jen slabé odkazy. Výsledek create_task si proto ulož, jinak ji může garbage collector uklidit rozběhnutou. „Spusť a zapomeň“ se dělá přes množinu úloh a task.add_done_callback(mnozina.discard), nebo rovnou přes TaskGroup.

Zrušení. task.cancel() vhodí CancelledError do místa, kde úloha čeká. Od 3.8 dědí z BaseException, aby ho nespolklo except Exception. Když ho chytíš, po úklidu ho vyhoď znovu. TaskGroup a asyncio.timeout podle task.cancelling() a task.uncancel() rozlišují vlastní zrušení od cizího, takže spolknutá výjimka jim rozbije logiku.

Výjimka v úloze, kterou nikdo nevyzvedl, se objeví až při úklidu objektu jako log Task exception was never retrieved. V produkci je to klasický zdroj tichých selhání.

Co smyčku zastaví

Celé to stojí na tom, že úlohy dobrovolně pouštějí ke slovu ostatní. Stačí jediné blokující volání a stojí všechno. Ukázka spustí stejnou dvojici úloh třemi způsoby. Sleduj pořadí řádků.

import asyncio
import time

async def spatne(jmeno, za):
    print(jmeno, "start")
    time.sleep(za)
    print(jmeno, "konec")

async def dobre(jmeno, za):
    print(jmeno, "start")
    await asyncio.sleep(za)
    print(jmeno, "konec")

async def ve_vlakne(jmeno, za):
    print(jmeno, "start")
    await asyncio.to_thread(time.sleep, za)
    print(jmeno, "konec")

async def main():
    for varianta in (spatne, dobre, ve_vlakne):
        print("---", varianta.__name__)
        await asyncio.gather(varianta("A", 0.2), varianta("B", 0.05))

asyncio.run(main())
Výstup
--- spatne
A start
A konec
B start
B konec
--- dobre
A start
B start
B konec
A konec
--- ve_vlakne
A start
B start
B konec
A konec

time.sleep podržel celé vlákno, takže úloha B nezačala dřív, než A skončila. Stejně se chová requests.get, běžný databázový ovladač nebo dlouhý výpočet. asyncio.to_thread pošle blokující funkci do pomocného vlákna a smyčka mezitím běží dál. Pro těžké počítání to nestačí, tam kvůli GIL potřebuješ procesy přes loop.run_in_executor a ProcessPoolExecutor.

Limity, fronty a timeouty

Spustit tisíc dotazů naráz umí gather snadno, ale server na druhé straně tě odřízne. Semafor je počítadlo volných míst: dovnitř smí jen daný počet úloh, ostatní čekají.

import asyncio

async def stahni(cislo, limit, stav):
    async with limit:
        stav["bezi"] += 1
        stav["spicka"] = max(stav["spicka"], stav["bezi"])
        await asyncio.sleep(0.01)
        stav["bezi"] -= 1
    return cislo * cislo

async def main():
    limit = asyncio.Semaphore(3)
    stav = {"bezi": 0, "spicka": 0}
    vysledky = await asyncio.gather(*(stahni(i, limit, stav) for i in range(10)))
    print(vysledky)
    print("nejvíc naráz:", stav["spicka"])

asyncio.run(main())
Výstup
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
nejvíc naráz: 3

Fronta rozděluje práci mezi pracovníky. maxsize omezí její délku, takže rychlý zdroj musí počkat na pomalé zpracování. join() počká, až se každá položka odškrtne přes task_done().

import asyncio

async def pracovnik(fronta, hotovo):
    while True:
        prace = await fronta.get()
        try:
            await asyncio.sleep(0.01)
            hotovo.append(prace * 2)
        finally:
            fronta.task_done()

async def main():
    fronta = asyncio.Queue(maxsize=2)
    hotovo = []
    async with asyncio.TaskGroup() as skupina:
        pracovnici = [skupina.create_task(pracovnik(fronta, hotovo)) for _ in range(3)]
        for prace in range(7):
            await fronta.put(prace)
        await fronta.join()
        for uloha in pracovnici:
            uloha.cancel()
    print(sorted(hotovo))

asyncio.run(main())
Výstup
[0, 2, 4, 6, 8, 10, 12]

Každé čekání na cizí systém potřebuje timeout, jinak jeden zaseknutý server drží úlohu navždy. asyncio.timeout po vypršení čekání zruší, takže proběhne i finally, a ven pustí běžný TimeoutError.

import asyncio

async def pomaly_dotaz():
    try:
        await asyncio.sleep(5)
        return "data"
    finally:
        print("úklid: zavírám spojení")

async def main():
    try:
        async with asyncio.timeout(0.05):
            print(await pomaly_dotaz())
    except TimeoutError:
        print("nestihlo se, jedu s náhradní hodnotou")

asyncio.run(main())
Výstup
úklid: zavírám spojení
nestihlo se, jedu s náhradní hodnotou

Poslední kus je async for. Prochází proud, jehož další položka může chvíli trvat, třeba stránky z API. Vyrobíš ho jako asynchronní generátor: async def, ve kterém je yield.

python
async def radky():
    yield "první"
    await asyncio.sleep(1)
    yield "druhý"

async def main():
    async for radek in radky():
        print(radek)
Úkol

Proud stránek

Napiš asynchronní generátor stranky(pocet), který pro každé číslo od 1 do pocet nejdřív počká přes await Pauza() a pak číslo vydá. Dále napiš korutinu soucet(proud), která přes async for sečte všechna čísla z proudu a součet vrátí. Pomocná funkce dobehni je hotová.

class Pauza:
    def __await__(self):
        yield

def dobehni(korutina):
    try:
        while True:
            korutina.send(None)
    except StopIteration as konec:
        return konec.value

async def stranky(pocet):
    # doplň: počkej a vydej čísla 1 až pocet
    return
    yield

async def soucet(proud):
    # doplň: async for
    return 0

print(dobehni(soucet(stranky(4))))
Výstup
Pod kapotou · eager úlohy a ladění

Python 3.12 přinesl asyncio.eager_task_factory. Úloha se rozběhne hned při vytvoření, a pokud doběhne bez čekání, do smyčky se vůbec nedostane. U kódu, kde se často trefíš do cache, to ušetří režii plánování. Mění to ale pořadí provádění, takže kód spoléhající na to, že úloha ještě nezačala, se může rozbít.

import asyncio

async def rychla():
    print("  úloha běží")
    return 1

async def ukazka(eager):
    if eager:
        asyncio.get_running_loop().set_task_factory(asyncio.eager_task_factory)
    uloha = asyncio.create_task(rychla())
    print("  po create_task, hotovo:", uloha.done())
    await uloha

for eager in (False, True):
    print("eager:", eager)
    asyncio.run(ukazka(eager))
Výstup
eager: False
  po create_task, hotovo: False
  úloha běží
eager: True
  úloha běží
  po create_task, hotovo: True

Při ladění zapni asyncio.run(main(), debug=True) nebo proměnnou PYTHONASYNCIODEBUG=1. Smyčka pak loguje callbacky delší než loop.slow_callback_duration (výchozí 0,1 s), a tím prozradí blokující volání. Zaseknuté úlohy ukáže asyncio.all_tasks() spolu s task.print_stack().

Objekty asyncio nejsou vláknově bezpečné. Z jiného vlákna do smyčky vstupuj jen přes loop.call_soon_threadsafe nebo asyncio.run_coroutine_threadsafe. Každá úloha dostává kopii kontextu (contextvars, PEP 567), takže ContextVar je správné místo pro ID požadavku. Obyčejná globální proměnná by se mezi úlohami pomíchala.

Vyzkoušej si: Smyčka událostí

Zjednodušený model: sleduj frontu úloh, spící úlohy a okamžiky, kdy úloha při await předá řízení.