Ve cvičení použijeme ukázku z PyQt5. Máte-li ještě virtualenv s nainstalovaným PyQt, použijte ho, případně ho podle lekce o PyQt nainstalujte znovu.
K PyQt si přiinstalujte knihovnu quamash:
$ python -m pip install quamash
Nejde-li to, nevadí – nezbytné dnes PyQt nebude.
Navíc si nainstalujte knihovnu aiohttp:
$ python -m pip install aiohttp
AsyncIO
Pojďme si povídat o souběžnosti – možnostech, jak nechat počítač dělat víc úloh věcí najednou.
Jak jsme si řekli v lekci o C API, Python má globální zámek, takže pythonní kód může běžet jen v jednom vlákně najednou. Taky jsme si řekli, že to většinou příliš nevadí: typický síťový nebo GUI program stráví hodně času čekáním na události (odpověď z internetu, kliknutí myší atp.) a u tohoto čekání není potřeba držet zámek zamčený.
Servery typicky při zpracovávání požadavku stráví většinu času síťovou komunikací.
Proto se často spouští několik vláken nebo přímo procesů najednou, aby se mohl vytížit
procesor.
Při velkém množství vláken ale nastanou dva problémy.
První je, že vláken nemůže být neomezeně mnoho.
Každé vlákno potřebuje vlastní stack, tj. poměrně velkou část paměti; a počet vláken
bývá omezen i jinak (na Linuxu je globální limit počtu procesů, do kterého se počítají
i jednotlivá vlákna – viz cat /proc/sys/kernel/threads-max).
Druhý problém je, že přepnutí z jednoho vlákna do druhého se může stát kdykoli.
Ověřit si, že je na to program připravený, je poměrně složité a na zajištění
správné funkčnosti je potřeba zamykání či jiné techniky. Ty bývají relativně
pomalé, a tak se jim programátoři snaží vyhnout.
A chyby vzniklé nesprávným ošetřením přepínání vláken bývají složité na odhalení
a vyřešení.
Vlákna jsou příklad preemptivního multitaskingu, kdy operační systém rozhoduje, kdy přepne z jednoho vlákna do druhého, a tuto změnu si prakticky vynutí. Jednotlivá vlákna se s tím musí vyrovnat. Alternativou je kooperativní multitasking, kdy se jednotlivé úlohy umí samy vzdát procesorového času, když např. čekají na síťovou komunikaci. Programátor tak ví, že dokud takto nepředá kontrolu ostatním úlohám, žádná jiná úloha mu pod rukama nemůže měnit stav procesu. Na druhou stranu je ale potřeba dostatečně často kontrolu předávat, aby se všechny úlohy dostaly ke slovu. Tuto techniku tak nemůže používat operační systém, pod kterým můžou běžet i špatně napsané programy. V rámci jednoho procesu se to ale dá s úspěchem využít.
Souběžnost v Pythonu
V Pythonu existovala a existuje řada knihoven, které nám umožňují „dělat více
věcí zároveň“.
Pro preemptivní multitasking jsou tu threading, tedy podpora pro vlákna,
a multiprocessing, tedy způsob jak spustit nový pythonní proces,
ve kterém se provede určitá funkce
(přičemž vstup a výstup se předává serializovaný přes pipes).
Další knihovna, kterou lze z PyPI nainstalovat, je greenlet. Ta nám dává k dispozici tzv. mikro-vlákna, která se mezi sebou přepínají v rámci jednoho procesu. Na rozdíl od systémových vláken nepotřebují tolik paměti navíc, ale stále jde (alespoň z pohledu programátora) o preemptivní strategii: k přepnutí může dojít kdykoli, je tedy potřeba zamykat a složitě hledat málo časté chyby.
Byly vyvinuty i knihovny pro kooperativní přepínání, založené na tzv. futures (které vysvětlíme vzápětí). Nejznámější jsou Twisted a Tornado. Obě jsou relativně staré (2002, resp. 2009), ale stále populární.
Ačkoli byly Twisted, Tornado a podobné knihovny užitečné, jejich problém byl v tom, že má každá jiné API. Vznikaly tak kolem nich ekosystémy vázané na konkrétní knihovnu: server napsaný pro Tornado se nedal použít pod Twisted a aplikace využívající Twisted nemohla využít knihovnu pro Tornado.
Jak to vyřešit?
Jeden standard
Komiks xkcd, © Randall Munroe, CC-BY-NC
Podobně jako přístup k různým SQL databázím je v Pythonu standardizovaný
(knihovny pro SQLite, Postgres, MySQL atd. všechny podporují API definované
v PEP 249) nebo je standardizované API webových serverů (WSGI, PEP 3333),
tak vzniklo standardizované API pro kooperativní multitasking.
Toto API je definováno v PEP 3156 a jeho referenční implementace, asyncio,
je od Pythonu 3.4 ve standardní knihovně.
(Pro Python 3.3 se dá asyncio nainstalovat pomocí pip.)
Interně je asyncio postavené na konceptu futures inspirovaných Tornado/Twisted,
ale jeho „hlavní“ API je postavené na coroutines podobných generátorům.
Od Pythonu verze 3.5 používá asyncio místo „normálních“ generátorů
speciální syntaxi, která umožňuje kombinovat asynchronní funkce s příkazy
for a with nebo i yield.
Tuto syntaxi použijeme i tady; máte-li starší Python, podívejte se na potřebné změny uvedené níže.
Jak vypadá taková asynchronní funkce?
Definuje se pomocí async def místo def, a může používat příkaz await.
Ukažme si to na příkladu:
import asyncio
async def count(name, interval):
"""Prints numbers from 0 in regular intervals"""
i = 0
while True:
print(name, 'counts', i)
await asyncio.sleep(interval)
i += 1
loop = asyncio.get_event_loop()
asyncio.ensure_future(count('Quick', 0.3))
asyncio.ensure_future(count('Slow', 1))
loop.run_forever()
loop.close()
Co se tu děje?
Příkazem await asyncio.sleep(interval) se asynchronní funkce zastaví
(podobně jako generátor při yield) a předá kontrolu knihovně asyncio
s informací že za daný čas by kontrolu chtěla zase zpátky.
Než daný interval uplyne, asyncio může spouštět jiné úlohy;
po jeho uplynutí naši čekající funkci „probudí“.
Spouštění a ukončení se dělá poněkud krkolomě. Pojďme se podívat co všechno se skrývá v posledních pěti příkazech.
V Pythonu verze 3.4 a nižší ještě neexistovala klíčová slova async a
await; asynchronní funkce byly opravdu implementovány jako generátory.
Máte-li starší verzi Pythonu, je potřeba místo:
async def ...:
await ...
psát:
@asyncio.coroutine
def ...:
yield from ...
Starý způsob zatím funguje i v novějším Pythonu, a dokonce se někdy objevuje i v dokumentaci.
Event Loop
Knihovna asyncio nám dává k dispozici smyčku událostí, která se, podobně jako
app.exec v Qt, stará o plánování jednotlivých úloh.
Každé vlákno může mít vlastní smyčku událostí, kterou získáme pomocí
asyncio.get_event_loop a pak ji můžeme spustit dvěma způsoby:
loop.run_forever()spustí smyčku na tak dlouho, dokud jsou nějaké úlohy naplánovány (to trochu odporuje názvu, ale většinou se nestává, že by se úlohy „vyčerpaly“), neboloop.run_until_complete(task)– tahle funkce skončí hned, jakmile je hotová daná úloha, a vrátí její výsledek.- Od Pythonu 3.7 můžete použít jednoduché
asyncio.run(task), aniž byste museli explicitně pracovat s určitou smyčkou událostí. Jedná se ale o API, které se v budoucnu může změnit.
Futures
Jak už bylo řečeno, knihovna asyncio je uvnitř založená na futures.
Copak to je?
Future je objekt, který reprezentuje budoucí výsledek nějaké operace.
Poté, co tato operace skončí, se výsledek dá zjistit pomocí metody result();
jestli je operace hotová se dá zjistit pomocí done().
Future je taková „krabička“ na vrácenou hodnotu – než tam něco
tu hodnotu dá, musíme počkat; poté je hodnota stále k dispozici.
Tohle čekání se dělá pomocí await (nebo loop.run_until_complete).
import asyncio
async def set_future(fut):
"""Sets the value of a Future, after a delay"""
print('set_future: sleeping...')
await asyncio.sleep(1)
print('set_future: setting future')
fut.set_result(123)
print('set_future done.')
async def get_future(fut):
"""Receives the value of a Future, once it's ready"""
print('get_future: waiting for future...')
await fut
print('get_future: getting result')
result = fut.result()
print('get_future: done')
return result
future = asyncio.Future()
# Schedule the "set_future" task (explained later)
asyncio.ensure_future(set_future(future))
# Run the "get_future" coroutine until complete
loop = asyncio.get_event_loop()
result = loop.run_until_complete(get_future(future))
loop.close()
print('Result is', result)
Do Future se dá vložit i výjimka.
To se využívá v případě, že úloha, která má Future naplnit, selže.
Metoda result() potom tuto výjimku způsobí v kódu, který by výsledek
zpracovával.
Na Future se navíc dají navázat funkce, které se zavolají, jakmile je
výsledek k dispozici.
Dá se tak implementovat callback styl programování (který možná znáte
např. z Node.js). Pomocí futures & callbacks se před nástupem
generátorů programovalo pro knihovny jako Twisted.
Podobně jako yield se await dá použít jako výraz, jehož
hodnota je výsledek dané Future.
Funkci get_future z příkladu výše tak lze napsat stručněji:
async def get_future(fut):
"""Receives the value of a Future, once it's ready"""
return (await fut)
Další vlastnost Future je ta, že se dá „zrušit“: pomocí Future.cancel()
signalizujeme úloze, která má připravit výsledek, že už ten výsledek
nepotřebujeme.
Po zrušení bude result() způsobovat CancelledError.
Async funkce a Task
Používání Future (nebo callback funkcí) je poněkud těžkopádné.
V asyncio se Future používají hlavně proto, že je na ně jednoduché
navázat existující knihovny.
Aplikační kód je ale lepší psát pomocí asynchronních funkcí, tak jako
v příkladu výše.
Asynchronní funkce se dají kombinovat pomocí await podobně jako generátory
pomocí yield from.
Nevýhoda asynchronních funkcí spočívá v tom, že na každé zavolání takové funkce
lze použít jen jeden await.
Na rozdíl od Future se výsledek nikam neukládá;
jen se po skončení jednou předá.
import asyncio
async def add(a, b):
await asyncio.sleep(1)
return a + b
async def demo():
coroutine = add(2, 3)
print('The result is:', (await coroutine))
print('The result is:', (await coroutine)) # chyba!
loop = asyncio.get_event_loop()
result = loop.run_until_complete(demo())
loop.close()
Tenhle problém můžeme vyřešit tak, že asynchronní funkci „zabalíme“ do Future.
Na to ma dokonce asyncio speciální funkci ensure_future, která:
- dostane-li asynchronní funkci, „zabalí“ ji do
Future, a - výsledek přímo naplánuje na smyčce událostí, takže se asynchronní funkce časem začne provádět.
async def demo():
coroutine = asyncio.ensure_future(add(2, 3))
print('The result is:', (await coroutine))
print('The result is:', (await coroutine)) # OK!
Výsledek ensure_future je speciální druh Future zvaný Task.
Ten má několik vlastností navíc, ale v podstatě ho zmiňujieme jen proto,
abyste věděli co Task znamená, až se vám objeví v chybové hlášce.
Fan-Out a Fan-In
S pomocí asynchronních funkcí můžeme nad našimi programy přemýšlet tak,
jako by to byly „normální“ procedurálně zapsané algoritmy: máme jedno
„vlákno“, které se provádí od začátku do konce, jen na některých místech
(označených await) se provádění přeruší a zatímco náš kód čeká na výsledek
nějaké operace, může se spustit jiný kus kódu.
Funkce, na které je takto potřeba čekat, bývají v dokumentaci patřičně
označeny (v síťovém programování je to většinou čtení ze socketů nebo inicializace
či ukončení serveru).
Pomocí ensure_future a await můžeme k tomu dělat něco navíc:
rozdělit běh našeho programu na víc úloh, které se budou vykonávat „souběžně“ –
například autor scraperu chce stáhnout několik stránek najednou
nebo server souběžně odpovídá na několik požadavků.
Tomuto rozdělení se říká fan-out.
Opačná operace je fan-in, kdy několik úloh opět spojíme do jedné.
Výše uvedený scraper může počkat, než jsou všechny stránky stažené –
třeba pomocí jednoho await pro každý Task, po kterém může
pokračovat zpracováním získaných dat.
Co se týče webového serveru, může se zdát, že tady není potřeba explicitně
počkat na výsledek každého úkolu.
Ale není to tak. I tady je poměrně důležité na každou úlohu nastartovanou
pomocí ensure_future „počkat“ pomocí např. await – už jen proto, abychom
zachytili případnou výjimku.
Neuděláme-li to, asyncio bude vypisovat varovné hlášky.
Asynchronní cykly a kontexty
Až budete používat některé „asynchronní“ knihovny, setkáte se pravděpodobně se dvěma
novými konstrukcemi: async for a async with.
Fungují jako jejich „ne-async“ varianty, jen na začátku a konci každé iterace (resp.
na začátku a konci bloku) můžou přerušit vykonávání funkce – podobně jako await.
Typický příklad je u databází: začátek a konec transakce i získávání jednotlivých řádků pravděpodobně potřebují komunikaci po síti, takže hypotetická databázová knihovna by se mohla používat nějak takto:
async with database.transaction_context():
await database.execute('UPDATE ...')
async for row in (await database.execute('SELECT ...')):
handle(row)
A další
Nakonec několik tipů, o kterých je dobré vědět.
V asyncio najdeme synchronizační mechanismy známé z vláknového programování, např.
Lock a Semaphore – viz dokumentace.
Musíme-li použít blokující funkci, která např. komunikuje po síti bez await a která by
tedy zablokovala i všechny ostatní úlohy, můžeme použít
loop.run_in_executor(), a tím danou funkci zavolat ve vlákně nebo podprocesu, ale výsledek zpřístupnit
pomocí asyncio.Future.
Použití je opět popsáno v dokumentaci.
Občas vás při programování s asyncio zaskočí zrádná chyba.
V takových případech je dobré zapnout debug režim pomocí proměnné prostředí PYTHONASYNCIODEBUG=1.
V tomto režimu asyncio upozorňuje na časté chyby, do některých chybových výpisů přidává informaci o tom,
kde aktuální Task vznikl, apod.
Více informací je zase v dokumentaci.
Alternativní smyčky událostí
Jak bylo zmíněno na začátku, hlavní cíl asyncio je definovat společné rozhraní
pro různé asynchronní knihovny, aby bylo možné např. kombinovat knihovny pro
Tornado se smyčkou událostí v Twisted.
Samotné asyncio je jen jedna z mnoha implementací tohoto rozhraní.
Zajímavá je například knihovna uvloop, která je asi 2-4× rychlejší než asyncio
(ale má závislosti, které se pro součást standardní knihovny nehodí).
Další zajímavá implementace je Quamash, která pod standardním asyncio API používá
smyčku událostí z Qt.
Umožňuje tak efektivně zpracovávat Qt události zároveň s asynchronními funkcemi
známými z asyncio.
Event loop z quamash je potřeba na začátku programu naimportovat a nastavit
jako hlavní smyčku událostí, a poté ji, místo Qt-ovského app.exec(), spustit.
Jednotlivé asynchronní funkce se pak používají jako v čistém asyncio:
pomocí asyncio.ensure_future, await, atd.
Ukázka:
import asyncio
from PyQt5 import QtGui, QtWidgets
from quamash import QEventLoop
app = QtWidgets.QApplication([])
loop = QEventLoop(app)
asyncio.set_event_loop(loop)
display = QtWidgets.QLCDNumber()
display.setWindowTitle('Stopwatch')
display.show()
async def update_time():
value = 0
while True:
display.display(value)
await asyncio.sleep(1)
value += 1
asyncio.ensure_future(update_time())
loop.run_forever()
Komunikace
Ono io v asyncio naznačuje, že je tato knihovna dělaná především na
vstup a výstup – konkrétně na komunikaci přes síť (případně s jinými procesy).
Ke komunikaci používá asyncio tři úrovně abstrakce: Transport, Protocol
a Stream.
V krátkosti si je tu popíšeme; detaily pak najdete v dokumentaci (je pro nás
totiž mnohem důležitější abyste pochopili principy, než abyste uměli konkrétní
API, které lze dohledat v dokumentaci).
Transporty a protokoly jsou postaveny na konceptech knihovny Twisted.
Transport zajišťuje samotné posílání bajtů mezi počítači (transportní vrstvu), kdežto
Protocol implementuje nějaký aplikační protokol.
Transport většinou nepíšeme sami, použijeme existující.
V asyncio jsou zabudované transporty pro TCP, UDP a SSL.
Protocol je pak použit pro implementaci konkrétních protokolů jako
HTTP, FTP a podobně.
V dokumentaci najdete podrobnější popis včetně příkladů.
Kromě toho existuje i „Stream API“ založené na asynchronních funkcích.
Většinou platí, že operace otevření, čtení, flush a zavření Streamu
jsou asynchronní funkce (v dokumentaci označované jako coroutines), a je
tedy nutné je použít s await; oproti tomu zápis asynchronní není – data
se uloží do bufferu a pošlou se, až to bude možné.
Typicky ale místo čistého asyncio použijeme existující knihovnu.
Tady je příklad z knihovny aiohttp, která implementuje server a klienta
pro HTTP:
import asyncio
import aiohttp
async def main(url):
# Use a a session
session = aiohttp.ClientSession()
async with session:
# Get the response (acts somewhat like a file; needs to be closed)
async with session.get(url) as response:
# Fetch the whole text
html = await response.text()
print(html)
loop = asyncio.get_event_loop()
loop.run_until_complete(main('http://python.cz'))
loop.close()
{
"data": {
"sessionMaterial": {
"id": "session-material:2019/brno-jaro-knihovny:threads:1",
"title": "AsyncIO",
"html": "\n \n \n\n <p>Ve cvičení použijeme ukázku z PyQt5.\nMáte-li ještě virtualenv s nainstalovaným PyQt, použijte ho, případně ho\npodle <a href=\"/2019/brno-jaro-knihovny/intro/pyqt/\">lekce o PyQt</a> nainstalujte znovu.</p>\n<p>K PyQt si přiinstalujte knihovnu <code>quamash</code>:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"gp\">$ </span>python -m pip install quamash\n</pre></div><p>Nejde-li to, nevadí – nezbytné dnes PyQt nebude.</p>\n<p>Navíc si nainstalujte knihovnu <code>aiohttp</code>:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"gp\">$ </span>python -m pip install aiohttp\n</pre></div><hr>\n<h1>AsyncIO</h1>\n<p>Pojďme si povídat o souběžnosti – možnostech, jak nechat počítač dělat víc\núloh věcí najednou.</p>\n<p>Jak jsme si řekli v <a href=\"/2019/brno-jaro-knihovny/intro/cython/\">lekci o C API</a>, Python má globální zámek, takže pythonní kód\nmůže běžet jen v jednom vlákně najednou.\nTaky jsme si řekli, že to většinou příliš nevadí: typický síťový nebo GUI program\nstráví hodně času čekáním na události (odpověď z internetu, kliknutí myší atp.)\na u tohoto čekání není potřeba držet zámek zamčený.</p>\n<p>Servery typicky při zpracovávání požadavku stráví <em>většinu</em> času síťovou komunikací.\nProto se často spouští několik vláken nebo přímo procesů najednou, aby se mohl vytížit\nprocesor.\nPři velkém množství vláken ale nastanou dva problémy.\nPrvní je, že vláken nemůže být neomezeně mnoho.\nKaždé vlákno potřebuje vlastní <em>stack</em>, tj. poměrně velkou část paměti; a počet vláken\nbývá omezen i jinak (na Linuxu je globální limit počtu procesů, do kterého se počítají\ni jednotlivá vlákna – viz <code>cat /proc/sys/kernel/threads-max</code>).\nDruhý problém je, že přepnutí z jednoho vlákna do druhého se může stát <em>kdykoli</em>.\nOvěřit si, že je na to program připravený, je poměrně složité a na zajištění\nsprávné funkčnosti je potřeba zamykání či jiné techniky. Ty bývají relativně\npomalé, a tak se jim programátoři snaží vyhnout.\nA chyby vzniklé nesprávným ošetřením přepínání vláken bývají složité na odhalení\na vyřešení.</p>\n<p>Vlákna jsou příklad <em>preemptivního multitaskingu</em>, kdy operační systém rozhoduje,\nkdy přepne z jednoho vlákna do druhého, a tuto změnu si prakticky vynutí.\nJednotlivá vlákna se s tím musí vyrovnat.\nAlternativou je <em>kooperativní multitasking</em>, kdy se jednotlivé úlohy umí <em>samy</em> vzdát\nprocesorového času, když např. čekají na síťovou komunikaci.\nProgramátor tak ví, že dokud takto nepředá kontrolu ostatním úlohám, žádná jiná\núloha mu pod rukama nemůže měnit stav procesu.\nNa druhou stranu je ale potřeba dostatečně často kontrolu předávat, aby se všechny\núlohy dostaly ke slovu.\nTuto techniku tak nemůže používat operační systém, pod kterým můžou běžet i špatně\nnapsané programy. V rámci jednoho procesu se to ale dá s úspěchem využít.</p>\n<h2>Souběžnost v Pythonu</h2>\n<p>V Pythonu existovala a existuje řada knihoven, které nám umožňují „dělat více\nvěcí zároveň“.\nPro preemptivní multitasking jsou tu <code>threading</code>, tedy podpora pro vlákna,\na <code>multiprocessing</code>, tedy způsob jak spustit nový pythonní proces,\nve kterém se provede určitá funkce\n(přičemž vstup a výstup se předává serializovaný přes <em>pipes</em>).</p>\n<p>Další knihovna, kterou lze z PyPI nainstalovat, je <a href=\"https://greenlet.readthedocs.io/en/latest/\">greenlet</a>.\nTa nám dává k dispozici tzv. <em>mikro-vlákna</em>,\nkterá se mezi sebou přepínají v rámci jednoho procesu.\nNa rozdíl od systémových vláken nepotřebují tolik paměti navíc, ale\nstále jde (alespoň z pohledu programátora) o <em>preemptivní</em> strategii:\nk přepnutí může dojít kdykoli,\nje tedy potřeba zamykat a složitě hledat málo časté chyby.</p>\n<p>Byly vyvinuty i knihovny pro <em>kooperativní</em> přepínání, založené na tzv.\n<em>futures</em> (které vysvětlíme vzápětí).\nNejznámější jsou <a href=\"https://twistedmatrix.com/trac/\">Twisted</a> a <a href=\"http://www.tornadoweb.org/en/stable/\">Tornado</a>.\nObě jsou relativně staré (2002, resp. 2009), ale stále populární.</p>\n<p>Ačkoli byly Twisted, Tornado a podobné knihovny užitečné, jejich problém\nbyl v tom, že má každá jiné API.\nVznikaly tak kolem nich ekosystémy vázané na konkrétní knihovnu:\nserver napsaný pro Tornado se nedal použít pod Twisted a aplikace\nvyužívající Twisted nemohla využít knihovnu pro Tornado.</p>\n<p>Jak to vyřešit?</p>\n<h2>Jeden standard</h2>\n<p><img src=\"https://imgs.xkcd.com/comics/standards.png\" alt=\"xkcd 927\"></p>\n<p><em>Komiks <a href=\"https://xkcd.com/927/\">xkcd</a>, © Randall Munroe, <a href=\"https://creativecommons.org/licenses/by-nc/2.5/\">CC-BY-NC</a></em></p>\n<p>Podobně jako přístup k různým SQL databázím je v Pythonu standardizovaný\n(knihovny pro SQLite, Postgres, MySQL atd. všechny podporují API definované\nv <a href=\"https://www.python.org/dev/peps/pep-0249/\">PEP 249</a>) nebo je standardizované API webových serverů (WSGI, <a href=\"https://www.python.org/dev/peps/pep-3333/\">PEP 3333</a>),\ntak vzniklo standardizované API pro kooperativní multitasking.\nToto API je definováno v <a href=\"https://www.python.org/dev/peps/pep-3156/\">PEP 3156</a> a jeho referenční implementace, <code>asyncio</code>,\nje od Pythonu 3.4 ve standardní knihovně.\n(Pro Python 3.3 se dá asyncio nainstalovat <a href=\"https://pypi.org/project/asyncio/\">pomocí <code>pip</code></a>.)\nInterně je <code>asyncio</code> postavené na konceptu <em>futures</em> inspirovaných Tornado/Twisted,\nale jeho „hlavní“ API je postavené na <em>coroutines</em> podobných generátorům.</p>\n<p>Od Pythonu verze 3.5 používá <code>asyncio</code> místo „normálních“ generátorů\nspeciální syntaxi, která umožňuje kombinovat asynchronní funkce s příkazy\n<code>for</code> a <code>with</code> nebo i <code>yield</code>.\nTuto syntaxi použijeme i tady; máte-li starší Python, podívejte se na potřebné změny uvedené níže.</p>\n<p>Jak vypadá taková asynchronní funkce?\nDefinuje se pomocí <code>async def</code> místo <code>def</code>, a může používat příkaz <code>await</code>.</p>\n<p>Ukažme si to na příkladu:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"kn\">import</span> <span class=\"nn\">asyncio</span>\n\n<span class=\"n\">async</span> <span class=\"k\">def</span> <span class=\"nf\">count</span><span class=\"p\">(</span><span class=\"n\">name</span><span class=\"p\">,</span> <span class=\"n\">interval</span><span class=\"p\">):</span>\n <span class=\"sd\">"""Prints numbers from 0 in regular intervals"""</span>\n <span class=\"n\">i</span> <span class=\"o\">=</span> <span class=\"mi\">0</span>\n <span class=\"k\">while</span> <span class=\"bp\">True</span><span class=\"p\">:</span>\n <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">name</span><span class=\"p\">,</span> <span class=\"s1\">'counts'</span><span class=\"p\">,</span> <span class=\"n\">i</span><span class=\"p\">)</span>\n <span class=\"n\">await</span> <span class=\"n\">asyncio</span><span class=\"o\">.</span><span class=\"n\">sleep</span><span class=\"p\">(</span><span class=\"n\">interval</span><span class=\"p\">)</span>\n <span class=\"n\">i</span> <span class=\"o\">+=</span> <span class=\"mi\">1</span>\n\n\n<span class=\"n\">loop</span> <span class=\"o\">=</span> <span class=\"n\">asyncio</span><span class=\"o\">.</span><span class=\"n\">get_event_loop</span><span class=\"p\">()</span>\n<span class=\"n\">asyncio</span><span class=\"o\">.</span><span class=\"n\">ensure_future</span><span class=\"p\">(</span><span class=\"n\">count</span><span class=\"p\">(</span><span class=\"s1\">'Quick'</span><span class=\"p\">,</span> <span class=\"mf\">0.3</span><span class=\"p\">))</span>\n<span class=\"n\">asyncio</span><span class=\"o\">.</span><span class=\"n\">ensure_future</span><span class=\"p\">(</span><span class=\"n\">count</span><span class=\"p\">(</span><span class=\"s1\">'Slow'</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"p\">))</span>\n<span class=\"n\">loop</span><span class=\"o\">.</span><span class=\"n\">run_forever</span><span class=\"p\">()</span>\n<span class=\"n\">loop</span><span class=\"o\">.</span><span class=\"n\">close</span><span class=\"p\">()</span>\n</pre></div><p>Co se tu děje?\nPříkazem <code>await asyncio.sleep(interval)</code> se asynchronní funkce zastaví\n(podobně jako generátor při <code>yield</code>) a předá kontrolu knihovně <code>asyncio</code>\ns informací že za daný čas by kontrolu chtěla zase zpátky.\nNež daný interval uplyne, <code>asyncio</code> může spouštět jiné úlohy;\npo jeho uplynutí naši čekající funkci „probudí“.</p>\n<p>Spouštění a ukončení se dělá poněkud krkolomě.\nPojďme se podívat co všechno se skrývá v posledních pěti příkazech.</p>\n<div class=\"admonition note\"><p>V Pythonu verze 3.4 a nižší ještě neexistovala klíčová slova <code>async</code> a\n<code>await</code>; asynchronní funkce byly opravdu implementovány jako generátory.\nMáte-li starší verzi Pythonu, je potřeba místo:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">async</span> <span class=\"k\">def</span> <span class=\"o\">...</span><span class=\"p\">:</span>\n <span class=\"n\">await</span> <span class=\"o\">...</span>\n</pre></div><p>psát:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"nd\">@asyncio.coroutine</span>\n<span class=\"k\">def</span> <span class=\"o\">...</span><span class=\"p\">:</span>\n <span class=\"k\">yield from</span> <span class=\"o\">...</span>\n</pre></div><p>Starý způsob zatím funguje i v novějším Pythonu, a dokonce se někdy objevuje\ni v dokumentaci.</p>\n</div><h2>Event Loop</h2>\n<p>Knihovna <code>asyncio</code> nám dává k dispozici <em>smyčku událostí</em>, která se, podobně jako\n<code>app.exec</code> v Qt, stará o plánování jednotlivých úloh.\nKaždé vlákno může mít vlastní smyčku událostí, kterou získáme pomocí\n<code>asyncio.get_event_loop</code> a pak ji můžeme spustit dvěma způsoby:</p>\n<ul>\n<li><code>loop.run_forever()</code> spustí smyčku na tak dlouho, dokud jsou nějaké úlohy\nnaplánovány (to trochu odporuje názvu, ale většinou se nestává, že by se\núlohy „vyčerpaly“), nebo</li>\n<li><code>loop.run_until_complete(task)</code> – tahle funkce skončí hned, jakmile je hotová\ndaná úloha, a vrátí její výsledek.</li>\n<li>Od Pythonu 3.7 můžete použít jednoduché <code>asyncio.run(task)</code>, aniž byste museli\nexplicitně pracovat s určitou smyčkou událostí. Jedná se ale o API, které se\nv budoucnu může změnit.</li>\n</ul>\n<h2>Futures</h2>\n<p>Jak už bylo řečeno, knihovna <code>asyncio</code> je uvnitř založená na <em>futures</em>.\nCopak to je?</p>\n<p><code>Future</code> je objekt, který reprezentuje budoucí výsledek nějaké operace.\nPoté, co tato operace skončí, se výsledek dá zjistit pomocí metody <code>result()</code>;\njestli je operace hotová se dá zjistit pomocí <code>done()</code>.\n<code>Future</code> je taková „krabička“ na vrácenou hodnotu – než tam něco\ntu hodnotu dá, musíme počkat; poté je hodnota stále k dispozici.\nTohle čekání se dělá pomocí <code>await</code> (nebo <code>loop.run_until_complete</code>).</p>\n<div class=\"highlight\"><pre><span></span><span class=\"kn\">import</span> <span class=\"nn\">asyncio</span>\n\n\n<span class=\"n\">async</span> <span class=\"k\">def</span> <span class=\"nf\">set_future</span><span class=\"p\">(</span><span class=\"n\">fut</span><span class=\"p\">):</span>\n <span class=\"sd\">"""Sets the value of a Future, after a delay"""</span>\n <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s1\">'set_future: sleeping...'</span><span class=\"p\">)</span>\n <span class=\"n\">await</span> <span class=\"n\">asyncio</span><span class=\"o\">.</span><span class=\"n\">sleep</span><span class=\"p\">(</span><span class=\"mi\">1</span><span class=\"p\">)</span>\n <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s1\">'set_future: setting future'</span><span class=\"p\">)</span>\n <span class=\"n\">fut</span><span class=\"o\">.</span><span class=\"n\">set_result</span><span class=\"p\">(</span><span class=\"mi\">123</span><span class=\"p\">)</span>\n <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s1\">'set_future done.'</span><span class=\"p\">)</span>\n\n\n<span class=\"n\">async</span> <span class=\"k\">def</span> <span class=\"nf\">get_future</span><span class=\"p\">(</span><span class=\"n\">fut</span><span class=\"p\">):</span>\n <span class=\"sd\">"""Receives the value of a Future, once it's ready"""</span>\n <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s1\">'get_future: waiting for future...'</span><span class=\"p\">)</span>\n <span class=\"n\">await</span> <span class=\"n\">fut</span>\n <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s1\">'get_future: getting result'</span><span class=\"p\">)</span>\n <span class=\"n\">result</span> <span class=\"o\">=</span> <span class=\"n\">fut</span><span class=\"o\">.</span><span class=\"n\">result</span><span class=\"p\">()</span>\n <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s1\">'get_future: done'</span><span class=\"p\">)</span>\n <span class=\"k\">return</span> <span class=\"n\">result</span>\n\n\n<span class=\"n\">future</span> <span class=\"o\">=</span> <span class=\"n\">asyncio</span><span class=\"o\">.</span><span class=\"n\">Future</span><span class=\"p\">()</span>\n\n\n<span class=\"c1\"># Schedule the "set_future" task (explained later)</span>\n<span class=\"n\">asyncio</span><span class=\"o\">.</span><span class=\"n\">ensure_future</span><span class=\"p\">(</span><span class=\"n\">set_future</span><span class=\"p\">(</span><span class=\"n\">future</span><span class=\"p\">))</span>\n\n\n<span class=\"c1\"># Run the "get_future" coroutine until complete</span>\n<span class=\"n\">loop</span> <span class=\"o\">=</span> <span class=\"n\">asyncio</span><span class=\"o\">.</span><span class=\"n\">get_event_loop</span><span class=\"p\">()</span>\n<span class=\"n\">result</span> <span class=\"o\">=</span> <span class=\"n\">loop</span><span class=\"o\">.</span><span class=\"n\">run_until_complete</span><span class=\"p\">(</span><span class=\"n\">get_future</span><span class=\"p\">(</span><span class=\"n\">future</span><span class=\"p\">))</span>\n<span class=\"n\">loop</span><span class=\"o\">.</span><span class=\"n\">close</span><span class=\"p\">()</span>\n\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s1\">'Result is'</span><span class=\"p\">,</span> <span class=\"n\">result</span><span class=\"p\">)</span>\n</pre></div><p>Do <code>Future</code> se dá vložit i výjimka.\nTo se využívá v případě, že úloha, která má <code>Future</code> naplnit, selže. \nMetoda <code>result()</code> potom tuto výjimku způsobí v kódu, který by výsledek\nzpracovával.</p>\n<p>Na <code>Future</code> se navíc dají navázat funkce, které se zavolají, jakmile je\nvýsledek k dispozici.\nDá se tak implementovat <em>callback</em> styl programování (který možná znáte\nnapř. z Node.js). Pomocí <em>futures & callbacks</em> se před nástupem\ngenerátorů programovalo pro knihovny jako <code>Twisted</code>.</p>\n<p>Podobně jako <code>yield</code> se <code>await</code> dá použít jako výraz, jehož\nhodnota je výsledek dané <code>Future</code>.\nFunkci <code>get_future</code> z příkladu výše tak lze napsat stručněji:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">async</span> <span class=\"k\">def</span> <span class=\"nf\">get_future</span><span class=\"p\">(</span><span class=\"n\">fut</span><span class=\"p\">):</span>\n <span class=\"sd\">"""Receives the value of a Future, once it's ready"""</span>\n <span class=\"k\">return</span> <span class=\"p\">(</span><span class=\"n\">await</span> <span class=\"n\">fut</span><span class=\"p\">)</span>\n</pre></div><p>Další vlastnost <code>Future</code> je ta, že se dá „zrušit“: pomocí <code>Future.cancel()</code>\nsignalizujeme úloze, která má připravit výsledek, že už ten výsledek\nnepotřebujeme.\nPo zrušení bude <code>result()</code> způsobovat <code>CancelledError</code>.</p>\n<h2>Async funkce a Task</h2>\n<p>Používání <code>Future</code> (nebo <em>callback</em> funkcí) je poněkud těžkopádné.\nV <code>asyncio</code> se <code>Future</code> používají hlavně proto, že je na ně jednoduché\nnavázat existující knihovny.\nAplikační kód je ale lepší psát pomocí asynchronních funkcí, tak jako\nv příkladu výše.</p>\n<p>Asynchronní funkce se dají kombinovat pomocí <code>await</code> podobně jako generátory\npomocí <code>yield from</code>.\nNevýhoda asynchronních funkcí spočívá v tom, že na každé zavolání takové funkce\nlze použít jen jeden <code>await</code>.\nNa rozdíl od <code>Future</code> se výsledek nikam neukládá;\njen se po skončení jednou předá.</p>\n<div class=\"highlight\"><pre><span></span><span class=\"kn\">import</span> <span class=\"nn\">asyncio</span>\n\n<span class=\"n\">async</span> <span class=\"k\">def</span> <span class=\"nf\">add</span><span class=\"p\">(</span><span class=\"n\">a</span><span class=\"p\">,</span> <span class=\"n\">b</span><span class=\"p\">):</span>\n <span class=\"n\">await</span> <span class=\"n\">asyncio</span><span class=\"o\">.</span><span class=\"n\">sleep</span><span class=\"p\">(</span><span class=\"mi\">1</span><span class=\"p\">)</span>\n <span class=\"k\">return</span> <span class=\"n\">a</span> <span class=\"o\">+</span> <span class=\"n\">b</span>\n\n<span class=\"n\">async</span> <span class=\"k\">def</span> <span class=\"nf\">demo</span><span class=\"p\">():</span>\n <span class=\"n\">coroutine</span> <span class=\"o\">=</span> <span class=\"n\">add</span><span class=\"p\">(</span><span class=\"mi\">2</span><span class=\"p\">,</span> <span class=\"mi\">3</span><span class=\"p\">)</span>\n <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s1\">'The result is:'</span><span class=\"p\">,</span> <span class=\"p\">(</span><span class=\"n\">await</span> <span class=\"n\">coroutine</span><span class=\"p\">))</span>\n <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s1\">'The result is:'</span><span class=\"p\">,</span> <span class=\"p\">(</span><span class=\"n\">await</span> <span class=\"n\">coroutine</span><span class=\"p\">))</span> <span class=\"c1\"># chyba!</span>\n\n\n<span class=\"n\">loop</span> <span class=\"o\">=</span> <span class=\"n\">asyncio</span><span class=\"o\">.</span><span class=\"n\">get_event_loop</span><span class=\"p\">()</span>\n<span class=\"n\">result</span> <span class=\"o\">=</span> <span class=\"n\">loop</span><span class=\"o\">.</span><span class=\"n\">run_until_complete</span><span class=\"p\">(</span><span class=\"n\">demo</span><span class=\"p\">())</span>\n<span class=\"n\">loop</span><span class=\"o\">.</span><span class=\"n\">close</span><span class=\"p\">()</span>\n</pre></div><p>Tenhle problém můžeme vyřešit tak, že asynchronní funkci „zabalíme“ do <code>Future</code>.\nNa to ma dokonce <code>asyncio</code> speciální funkci <code>ensure_future</code>, která:</p>\n<ul>\n<li>dostane-li asynchronní funkci, „zabalí“ ji do <code>Future</code>, a</li>\n<li>výsledek přímo naplánuje na smyčce událostí, takže se asynchronní funkce\nčasem začne provádět.</li>\n</ul>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">async</span> <span class=\"k\">def</span> <span class=\"nf\">demo</span><span class=\"p\">():</span>\n <span class=\"n\">coroutine</span> <span class=\"o\">=</span> <span class=\"n\">asyncio</span><span class=\"o\">.</span><span class=\"n\">ensure_future</span><span class=\"p\">(</span><span class=\"n\">add</span><span class=\"p\">(</span><span class=\"mi\">2</span><span class=\"p\">,</span> <span class=\"mi\">3</span><span class=\"p\">))</span>\n <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s1\">'The result is:'</span><span class=\"p\">,</span> <span class=\"p\">(</span><span class=\"n\">await</span> <span class=\"n\">coroutine</span><span class=\"p\">))</span>\n <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s1\">'The result is:'</span><span class=\"p\">,</span> <span class=\"p\">(</span><span class=\"n\">await</span> <span class=\"n\">coroutine</span><span class=\"p\">))</span> <span class=\"c1\"># OK!</span>\n</pre></div><div class=\"admonition note\"><p>Výsledek <code>ensure_future</code> je speciální druh <code>Future</code> zvaný <code>Task</code>.\nTen má několik vlastností navíc, ale v podstatě ho zmiňujieme jen proto,\nabyste věděli co <code>Task</code> znamená, až se vám objeví v chybové hlášce.</p>\n</div><h2>Fan-Out a Fan-In</h2>\n<p>S pomocí asynchronních funkcí můžeme nad našimi programy přemýšlet tak,\njako by to byly „normální“ procedurálně zapsané algoritmy: máme jedno\n„vlákno“, které se provádí od začátku do konce, jen na některých místech\n(označených <code>await</code>) se provádění přeruší a zatímco náš kód čeká na výsledek\nnějaké operace, může se spustit jiný kus kódu.\nFunkce, na které je takto potřeba čekat, bývají v dokumentaci patřičně\noznačeny (v síťovém programování je to většinou čtení ze socketů nebo inicializace\nči ukončení serveru).</p>\n<p>Pomocí <code>ensure_future</code> a <code>await</code> můžeme k tomu dělat něco navíc:\nrozdělit běh našeho programu na víc úloh, které se budou vykonávat „souběžně“ –\nnapříklad autor scraperu chce stáhnout několik stránek najednou\nnebo server souběžně odpovídá na několik požadavků.\nTomuto rozdělení se říká <em>fan-out</em>.</p>\n<p>Opačná operace je <em>fan-in</em>, kdy několik úloh opět spojíme do jedné.\nVýše uvedený scraper může počkat, než jsou všechny stránky stažené –\ntřeba pomocí jednoho <code>await</code> pro každý <code>Task</code>, po kterém může\npokračovat zpracováním získaných dat.</p>\n<p>Co se týče webového serveru, může se zdát, že tady není potřeba explicitně\npočkat na výsledek každého úkolu.\nAle není to tak. I tady je poměrně důležité na každou úlohu nastartovanou\npomocí <code>ensure_future</code> „počkat“ pomocí např. <code>await</code> – už jen proto, abychom\nzachytili případnou výjimku.\nNeuděláme-li to, <code>asyncio</code> bude vypisovat varovné hlášky.</p>\n<h2>Asynchronní cykly a kontexty</h2>\n<p>Až budete používat některé „asynchronní“ knihovny, setkáte se pravděpodobně se dvěma\nnovými konstrukcemi: <code>async for</code> a <code>async with</code>.</p>\n<p>Fungují jako jejich „ne-<code>async</code>“ varianty, jen na začátku a konci každé iterace (resp.\nna začátku a konci bloku) můžou přerušit vykonávání funkce – podobně jako <code>await</code>.</p>\n<p>Typický příklad je u databází: začátek a konec transakce i získávání jednotlivých\nřádků pravděpodobně potřebují komunikaci po síti, takže hypotetická databázová\nknihovna by se mohla používat nějak takto:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">async</span> <span class=\"k\">with</span> <span class=\"n\">database</span><span class=\"o\">.</span><span class=\"n\">transaction_context</span><span class=\"p\">():</span>\n <span class=\"n\">await</span> <span class=\"n\">database</span><span class=\"o\">.</span><span class=\"n\">execute</span><span class=\"p\">(</span><span class=\"s1\">'UPDATE ...'</span><span class=\"p\">)</span>\n <span class=\"n\">async</span> <span class=\"k\">for</span> <span class=\"n\">row</span> <span class=\"ow\">in</span> <span class=\"p\">(</span><span class=\"n\">await</span> <span class=\"n\">database</span><span class=\"o\">.</span><span class=\"n\">execute</span><span class=\"p\">(</span><span class=\"s1\">'SELECT ...'</span><span class=\"p\">)):</span>\n <span class=\"n\">handle</span><span class=\"p\">(</span><span class=\"n\">row</span><span class=\"p\">)</span>\n</pre></div><h2>A další</h2>\n<p>Nakonec několik tipů, o kterých je dobré vědět.</p>\n<p>V <code>asyncio</code> najdeme synchronizační mechanismy známé z vláknového programování, např.\n<code>Lock</code> a <code>Semaphore</code> – viz <a href=\"https://docs.python.org/3/library/asyncio-sync.html\">dokumentace</a>.</p>\n<p>Musíme-li použít blokující funkci, která např. komunikuje po síti bez <code>await</code> a která by\ntedy zablokovala i všechny ostatní úlohy, můžeme použít\n<code>loop.run_in_executor()</code>, a tím danou funkci zavolat ve vlákně nebo podprocesu, ale výsledek zpřístupnit\npomocí <code>asyncio.Future</code>.\nPoužití je opět popsáno v <a href=\"https://docs.python.org/3/library/asyncio-eventloop.html#executor\">dokumentaci</a>.</p>\n<p>Občas vás při programování s <code>asyncio</code> zaskočí zrádná chyba.\nV takových případech je dobré zapnout <em>debug</em> režim pomocí proměnné prostředí <code>PYTHONASYNCIODEBUG=1</code>.\nV tomto režimu asyncio upozorňuje na časté chyby, do některých chybových výpisů přidává informaci o tom,\nkde aktuální <code>Task</code> vznikl, apod.\nVíce informací je zase v <a href=\"https://docs.python.org/3/library/asyncio-dev.html#asyncio-dev\">dokumentaci</a>.</p>\n<h2>Alternativní smyčky událostí</h2>\n<p>Jak bylo zmíněno na začátku, hlavní cíl <code>asyncio</code> je definovat společné rozhraní\npro různé asynchronní knihovny, aby bylo možné např. kombinovat knihovny pro\nTornado se smyčkou událostí v Twisted.\nSamotné <code>asyncio</code> je jen jedna z mnoha implementací tohoto rozhraní.\nZajímavá je například knihovna <a href=\"https://pypi.org/project/uvloop/\">uvloop</a>, která je asi 2-4× rychlejší než <code>asyncio</code>\n(ale má závislosti, které se pro součást standardní knihovny nehodí).</p>\n<p>Další zajímavá implementace je <a href=\"https://pypi.org/project/Quamash/\">Quamash</a>, která pod standardním <code>asyncio</code> API používá\nsmyčku událostí z Qt.\nUmožňuje tak efektivně zpracovávat Qt události zároveň s asynchronními funkcemi\nznámými z <code>asyncio</code>.</p>\n<p><em>Event loop</em> z <code>quamash</code> je potřeba na začátku programu naimportovat a nastavit\njako hlavní smyčku událostí, a poté ji, místo Qt-ovského <code>app.exec()</code>, spustit.\nJednotlivé asynchronní funkce se pak používají jako v čistém <code>asyncio</code>:\npomocí <code>asyncio.ensure_future</code>, <code>await</code>, atd.</p>\n<p>Ukázka:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"kn\">import</span> <span class=\"nn\">asyncio</span>\n\n<span class=\"kn\">from</span> <span class=\"nn\">PyQt5</span> <span class=\"kn\">import</span> <span class=\"n\">QtGui</span><span class=\"p\">,</span> <span class=\"n\">QtWidgets</span>\n<span class=\"kn\">from</span> <span class=\"nn\">quamash</span> <span class=\"kn\">import</span> <span class=\"n\">QEventLoop</span>\n\n<span class=\"n\">app</span> <span class=\"o\">=</span> <span class=\"n\">QtWidgets</span><span class=\"o\">.</span><span class=\"n\">QApplication</span><span class=\"p\">([])</span>\n<span class=\"n\">loop</span> <span class=\"o\">=</span> <span class=\"n\">QEventLoop</span><span class=\"p\">(</span><span class=\"n\">app</span><span class=\"p\">)</span>\n<span class=\"n\">asyncio</span><span class=\"o\">.</span><span class=\"n\">set_event_loop</span><span class=\"p\">(</span><span class=\"n\">loop</span><span class=\"p\">)</span>\n\n<span class=\"n\">display</span> <span class=\"o\">=</span> <span class=\"n\">QtWidgets</span><span class=\"o\">.</span><span class=\"n\">QLCDNumber</span><span class=\"p\">()</span>\n<span class=\"n\">display</span><span class=\"o\">.</span><span class=\"n\">setWindowTitle</span><span class=\"p\">(</span><span class=\"s1\">'Stopwatch'</span><span class=\"p\">)</span>\n\n<span class=\"n\">display</span><span class=\"o\">.</span><span class=\"n\">show</span><span class=\"p\">()</span>\n\n<span class=\"n\">async</span> <span class=\"k\">def</span> <span class=\"nf\">update_time</span><span class=\"p\">():</span>\n <span class=\"n\">value</span> <span class=\"o\">=</span> <span class=\"mi\">0</span>\n <span class=\"k\">while</span> <span class=\"bp\">True</span><span class=\"p\">:</span>\n <span class=\"n\">display</span><span class=\"o\">.</span><span class=\"n\">display</span><span class=\"p\">(</span><span class=\"n\">value</span><span class=\"p\">)</span>\n <span class=\"n\">await</span> <span class=\"n\">asyncio</span><span class=\"o\">.</span><span class=\"n\">sleep</span><span class=\"p\">(</span><span class=\"mi\">1</span><span class=\"p\">)</span>\n <span class=\"n\">value</span> <span class=\"o\">+=</span> <span class=\"mi\">1</span>\n\n<span class=\"n\">asyncio</span><span class=\"o\">.</span><span class=\"n\">ensure_future</span><span class=\"p\">(</span><span class=\"n\">update_time</span><span class=\"p\">())</span>\n\n<span class=\"n\">loop</span><span class=\"o\">.</span><span class=\"n\">run_forever</span><span class=\"p\">()</span>\n</pre></div><h2>Komunikace</h2>\n<p>Ono <code>io</code> v <code>asyncio</code> naznačuje, že je tato knihovna dělaná především na\nvstup a výstup – konkrétně na komunikaci přes síť (případně s jinými procesy).</p>\n<p>Ke komunikaci používá <code>asyncio</code> tři úrovně abstrakce: <code>Transport</code>, <code>Protocol</code>\na <code>Stream</code>.\nV krátkosti si je tu popíšeme; detaily pak najdete v dokumentaci (je pro nás\ntotiž mnohem důležitější abyste pochopili principy, než abyste uměli konkrétní\nAPI, které lze dohledat v dokumentaci).</p>\n<p>Transporty a protokoly jsou postaveny na konceptech knihovny <code>Twisted</code>.</p>\n<p><code>Transport</code> zajišťuje samotné posílání bajtů mezi počítači (transportní vrstvu), kdežto\n<code>Protocol</code> implementuje nějaký aplikační protokol.\n<code>Transport</code> většinou nepíšeme sami, použijeme existující.\nV <code>asyncio</code> jsou zabudované transporty pro TCP, UDP a SSL.\n<code>Protocol</code> je pak použit pro implementaci konkrétních protokolů jako\n<code>HTTP</code>, <code>FTP</code> a podobně.\nV dokumentaci najdete podrobnější popis včetně <a href=\"https://docs.python.org/3/library/asyncio-protocol.html#tcp-echo-server-protocol\">příkladů</a>.</p>\n<p>Kromě toho existuje i „Stream API“ založené na asynchronních funkcích.\nVětšinou platí, že operace <em>otevření</em>, <em>čtení</em>, <em>flush</em> a <em>zavření</em> Streamu\njsou asynchronní funkce (v dokumentaci označované jako <em>coroutines</em>), a je\ntedy nutné je použít s <code>await</code>; oproti tomu <em>zápis</em> asynchronní není – data\nse uloží do bufferu a pošlou se, až to bude možné.</p>\n<p>Typicky ale místo čistého <code>asyncio</code> použijeme existující knihovnu.\nTady je příklad z knihovny <code>aiohttp</code>, která implementuje server a klienta\npro HTTP:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"kn\">import</span> <span class=\"nn\">asyncio</span>\n<span class=\"kn\">import</span> <span class=\"nn\">aiohttp</span>\n\n<span class=\"n\">async</span> <span class=\"k\">def</span> <span class=\"nf\">main</span><span class=\"p\">(</span><span class=\"n\">url</span><span class=\"p\">):</span>\n <span class=\"c1\"># Use a a session</span>\n <span class=\"n\">session</span> <span class=\"o\">=</span> <span class=\"n\">aiohttp</span><span class=\"o\">.</span><span class=\"n\">ClientSession</span><span class=\"p\">()</span>\n <span class=\"n\">async</span> <span class=\"k\">with</span> <span class=\"n\">session</span><span class=\"p\">:</span>\n\n <span class=\"c1\"># Get the response (acts somewhat like a file; needs to be closed)</span>\n <span class=\"n\">async</span> <span class=\"k\">with</span> <span class=\"n\">session</span><span class=\"o\">.</span><span class=\"n\">get</span><span class=\"p\">(</span><span class=\"n\">url</span><span class=\"p\">)</span> <span class=\"k\">as</span> <span class=\"n\">response</span><span class=\"p\">:</span>\n\n <span class=\"c1\"># Fetch the whole text</span>\n <span class=\"n\">html</span> <span class=\"o\">=</span> <span class=\"n\">await</span> <span class=\"n\">response</span><span class=\"o\">.</span><span class=\"n\">text</span><span class=\"p\">()</span>\n <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">html</span><span class=\"p\">)</span>\n\n<span class=\"n\">loop</span> <span class=\"o\">=</span> <span class=\"n\">asyncio</span><span class=\"o\">.</span><span class=\"n\">get_event_loop</span><span class=\"p\">()</span>\n<span class=\"n\">loop</span><span class=\"o\">.</span><span class=\"n\">run_until_complete</span><span class=\"p\">(</span><span class=\"n\">main</span><span class=\"p\">(</span><span class=\"s1\">'http://python.cz'</span><span class=\"p\">))</span>\n<span class=\"n\">loop</span><span class=\"o\">.</span><span class=\"n\">close</span><span class=\"p\">()</span>\n</pre></div>\n\n\n "
}
}
}