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.
| Situace | Co zvolit |
|---|---|
| Stovky spojení, většinu času se čeká | asyncio |
Pár souběžných čekání a knihovny bez podpory async | vlákna |
| Těžký výpočet na procesoru | procesy |
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)
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.
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()))
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)])
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á.
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)]))
Jedna úloha začne počítat dlouhý cyklus a nemá v něm žádné await. Co dělají ostatní úlohy?
Přepnutí nastane jen na await, který opravdu čeká. Nikdo úlohu násilím nepřeruší, na rozdíl od vláken.
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()))
--- 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.
Kolik zhruba trvá await a() a hned po něm await b(), když každá korutina sekundu čeká přes asyncio.sleep(1)?
await čeká na dokončení. Ostatní úlohy mezitím běžet mohou, ale tahle jde krok za krokem. Souběh vznikne až přes gather, create_task nebo TaskGroup.
Ú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())
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())
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())
--- 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())
[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())
[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())
ú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.
async def radky():
yield "první"
await asyncio.sleep(1)
yield "druhý"
async def main():
async for radek in radky():
print(radek)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))))
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))
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í.