Asyncio: Eine Einführung

Begriffe

Das asyncio-Modul stellt ein Framework bereit, dessen Kern der Event-Loop ist. Ein Event-Loop wartet im Grunde darauf, dass etwas passiert, und reagiert dann auf das Ereignis. Er ist zuständig für Dinge wie I/O- und Systemereignisse.

asyncio bringt tatsächlich mehrere Loop-Implementierungen mit. Standardmäßig wählt das Modul die für das jeweilige Betriebssystem voraussichtlich effizienteste aus; du kannst den Event-Loop aber auch explizit festlegen. Ein Event-Loop folgt dem Prinzip: „Wenn Ereignis A eintritt, reagiere mit Funktion B“.

Denk an einen Server, der darauf wartet, dass jemand eine Ressource anfragt, zum Beispiel eine Webseite. Ist die Seite nicht sehr populär, ist der Server lange untätig. Kommt eine Anfrage, muss er reagieren. Diese Reaktion nennt man Event-Handling. Wenn ein User die Seite lädt, prüft der Server einen oder mehrere Event-Handler und ruft sie auf. Sobald diese fertig sind, geben sie die Kontrolle an den Event-Loop zurück. In Python nutzt asyncio dafür Coroutinen.

Eine Coroutine ist eine spezielle Funktion, die die Kontrolle an ihren Aufrufer abgeben kann, ohne ihren Zustand zu verlieren. Sie ist ein Verbraucher und eine Weiterentwicklung eines Generators. Ein großer Vorteil gegenüber Threads: Sie benötigen sehr wenig Speicher. Beachte: Wenn du eine Coroutine-Funktion aufrufst, wird sie nicht sofort ausgeführt. Stattdessen gibt sie ein Coroutine-Objekt zurück, das du dem Event-Loop übergeben kannst – zur sofortigen oder späteren Ausführung.

Ein weiterer Begriff, dem du bei asyncio begegnest, ist Future. Eine Future ist ein Objekt, das das Ergebnis einer noch nicht abgeschlossenen Arbeit repräsentiert. Dein Event-Loop kann Futures beobachten und auf deren Abschluss warten. Wenn eine Future fertig ist, steht sie auf done. Asyncio unterstützt außerdem Locks und Semaphore.

Zuletzt noch die Task. Eine Task ist ein Wrapper um eine Coroutine und eine Unterklasse von Future. Tasks lassen sich auch über den Event-Loop planen.

async und await

Die Schlüsselwörter async und await kamen mit Python 3.5 hinzu, um native Coroutinen zu definieren und sie klar von generatorbasierten Coroutinen abzugrenzen. Für eine detaillierte Beschreibung von async und await lies PEP 492.

In Python 3.4 würdest du eine Coroutine so erstellen:

# Python 3.4 coroutine example
# Import `asyncio`
import _______
 
@asyncio.coroutine
def my_coro():
    yield from func()

Dieser Decorator funktioniert auch in Python 3.5 noch, aber das types-Modul hat eine Erweiterung in Form einer coroutine function erhalten, die dir nun sagen kann, ob es sich um eine native Coroutine handelt oder nicht. Ab Python 3.5 kannst du mit async def eine Coroutine-Funktion auch syntaktisch definieren.

Die Funktion von oben sähe dann so aus:

import _______
 
async def _______():
    await func()

Wenn du eine Coroutine auf diese Weise definierst, kannst du innerhalb der Funktion kein yield verwenden. Stattdessen muss sie eine return- oder await-Anweisung enthalten, um Werte an den Aufrufer zurückzugeben. Beachte: Das Schlüsselwort await darf nur in einer async def-Funktion verwendet werden.

Die Schlüsselwörter async/await kannst du als API für asynchrones Programmieren betrachten. Das asyncio-Modul ist „nur“ ein Framework, das async/await für asynchrone Programmierung nutzt. Es gibt sogar ein Projekt namens curio, das dieses Konzept belegt – eine separate Event-Loop-Implementierung, die unter der Haube async/await verwendet.

Ein schlechtes Coroutine-Beispiel

Hintergrundwissen ist hilfreich, aber manchmal willst du einfach Beispiele sehen, um ein Gefühl für die Syntax und das Zusammenspiel der Teile zu bekommen.

Fangen wir also mit einem einfachen Beispiel an!

Eine ziemlich typische Aufgabe ist das Herunterladen einer Datei – sei es aus einer internen Quelle oder aus dem Internet. Meistens willst du gleich mehrere Dateien herunterladen.

Lass uns dafür zwei Coroutinen schreiben:

import asyncio
import os
import urllib.request
 
async def download_coroutine(url):
    #"A coroutine to download the specified url"
    request = urllib.request.urlopen(url)
    filename = os.path.basename(url)
 
    with open(filename, 'wb') as file_handle:
        while True:
            chunk = request.read(1024)
            if not chunk:
                break
            file_handle.write(chunk)
    msg = 'Finished downloading {filename}'.format(filename=filename)
    return msg
 
async def main(urls):
    """
    Creates a group of coroutines and waits for them to finish
    """
    coroutines = [download_coroutine(url) for url in urls]
    completed, pending = await asyncio.wait(coroutines)
    for item in completed:
        print(item.result())
 
 
if __name__ == '__main__':
    urls = ["http://www.irs.gov/pub/irs-pdf/f1040.pdf",
            "http://www.irs.gov/pub/irs-pdf/f1040a.pdf",
            "http://www.irs.gov/pub/irs-pdf/f1040ez.pdf",
            "http://www.irs.gov/pub/irs-pdf/f1040es.pdf",
            "http://www.irs.gov/pub/irs-pdf/f1040sb.pdf"]
 
    event_loop = asyncio.get_event_loop()
    try:
        event_loop.run_until_complete(main(urls))
    finally:
        event_loop.close()Bereitgestellt von

Hier importieren wir die benötigten Module und erstellen mit der async-Syntax unsere erste Coroutine. Diese Coroutine heißt download_coroutine und nutzt Pythons urllib, um die übergebene URL herunterzuladen. Ist sie fertig, gibt sie eine entsprechende Meldung zurück.

Die andere Coroutine ist unsere Main-Coroutine. Sie nimmt eine Liste aus einer oder mehreren URLs, reiht sie in die Warteschlange ein und wartet mit asyncio.wait auf deren Abschluss. Damit die Coroutinen überhaupt starten, müssen sie dem Event-Loop hinzugefügt werden. Das geschieht am Ende: Wir holen uns den Event-Loop und rufen seine Methode run_until_complete auf. Der Event-Loop erhält die Main-Coroutine, welche die zweite Coroutine einreiht und startet. Das nennt man eine verkettete Coroutine.

Das Problem an diesem Beispiel: Eigentlich ist es gar nicht asynchron. Der Grund ist, dass die Funktion download_coroutine nicht asynchron arbeitet. urllib ist nicht asynchron, und außerdem verwenden wir weder await noch yield. Besser wäre hier das Paket aiohttp. Schauen wir uns das als Nächstes an!

Ein besseres Coroutine-Beispiel

Das Paket aiohttp ist für die Erstellung asynchroner HTTP-Clients und -Server gedacht. Du kannst es mit pip so installieren:

pip install aiohttpBereitgestellt von

Nachdem es installiert ist, passen wir unseren Code an aiohttp an, um die Dateien herunterzuladen:

import aiohttp
import asyncio
import async_timeout
import os
 
async def download_coroutine(session, url):
    with async_timeout.timeout(10):
        async with session.get(url) as response:
            filename = __.path.basename(url)
            with open(________, 'wb') as f_handle:
                while True:
                    chunk = await response.content.read(1024)
                    if not chunk:
                        break
                    f_handle.write(_____)
            return await response.release()
 
async def main(loop):
    urls = ["http://www.irs.gov/pub/irs-pdf/f1040.pdf",
        "http://www.irs.gov/pub/irs-pdf/f1040a.pdf",
        "http://www.irs.gov/pub/irs-pdf/f1040ez.pdf",
        "http://www.irs.gov/pub/irs-pdf/f1040es.pdf",
        "http://www.irs.gov/pub/irs-pdf/f1040sb.pdf"]
 
    async with aiohttp.ClientSession(loop=loop) as session:
        tasks = [download_coroutine(session, url) for url in urls]
        await asyncio.gather(*tasks)
 
if __name__ == '__main__':
    loop = asyncio.get_event_loop()
    loop.run_until_complete(main(loop))

Hier importieren wir zwei neue Bausteine: aiohttp und async_timeout. Letzteres ist eine Abhängigkeit von aiohttp und ermöglicht uns einen Timeout-Context-Manager. Gehen wir von unten nach oben durch den Code: In der unteren Bedingung starten wir den asynchronen Event-Loop und rufen unsere Main-Funktion auf.

In der Main-Funktion erstellen wir ein ClientSession-Objekt, das wir an unsere Download-Coroutine für jede zu ladende URL übergeben. In download_coroutine erzeugen wir mit async_timeout.timeout() einen Context-Manager, der im Grunde einen Timer von X Sekunden setzt. Läuft die Zeit ab, endet der Context-Manager. Hier beträgt das Timeout 10 Sekunden. Anschließend rufen wir get() auf der Session auf und erhalten ein Response-Objekt. Jetzt kommt der magische Teil: Über das Attribut content des Response-Objekts erhalten wir eine Instanz von aiohttp.StreamReader, mit der wir die Datei in frei wählbaren Chunk-Größen herunterladen können. Während wir lesen, schreiben wir auf die lokale Platte. Zum Schluss rufen wir release() der Response auf, um die Verarbeitung abzuschließen.

Laut aiohttp-Dokumentation wird release() implizit aufgerufen, da das Response-Objekt in einem Context-Manager erstellt wurde. In Python gilt jedoch meist: Explizit ist besser als implizit. Zudem rät die Doku davon ab, sich darauf zu verlassen, dass die Verbindung einfach verschwindet – daher ist es hier besser, explizit zu releasen.

Ein Teil blockiert hier weiterhin: das Schreiben auf die Festplatte. Während des Schreibens blockieren wir noch. Es gibt eine weitere Bibliothek namens aiofiles, mit der sich auch das Dateischreiben asynchronisieren ließe. Dieses Update überlasse ich dir.

Aufrufe planen

Du kannst mit dem asyncio-Event-Loop auch Aufrufe regulärer Funktionen planen. Die erste Methode ist call_soon. Sie ruft deinen Callback bzw. Event-Handler so schnell wie möglich auf. Die Ausführung folgt einer FIFO-Warteschlange. Dauern einige Callbacks länger, verzögern sich die nachfolgenden, bis die vorherigen fertig sind.

Ein Beispiel:

import ______
import functools
 
def event_handler(loop, stop=False):
    print('Event handler called')
    if stop:
        print('stopping the loop')
        loop.stop()

if __name__ == '__main__':
    loop = asyncio.get_event_loop()
    try:
        loop.call_soon(functools.partial(_____________, ____))
        print('starting event loop')
        loop.call_soon(functools.partial(_____________, ____, stop=True))
 
        loop.__________()
    finally:
        print('closing event loop')
        loop._____()

Die meisten Funktionen von asyncio akzeptieren keine Keyword-Argumente, daher brauchen wir für Schlüsselwörter das Modul functools. Unsere reguläre Funktion schreibt bei jedem Aufruf Text auf stdout. Setzt du das Argument stop auf True, stoppt sie außerdem den Event-Loop.

Beim ersten Aufruf stoppen wir den Loop nicht. Beim zweiten Aufruf stoppen wir ihn. Das ist nötig, weil wir run_forever aufgerufen haben – der Event-Loop würde sonst endlos laufen. Ist der Loop gestoppt, können wir ihn schließen.

Wenn du den Code startest, solltest du diese Ausgabe sehen:

starting event loop
Event handler called
Event handler called
stopping the loop
closing event loopBereitgestellt von

Verwandt ist die Funktion call_soon_threadsafe. Wie der Name vermuten lässt, funktioniert sie wie call_soon, ist aber thread-sicher. Wenn du einen Aufruf gezielt verzögern möchtest, kannst du call_later verwenden. In unserem Beispiel könnten wir die call_soon-Signatur so ändern:

loop.call_later(1, event_handler, loop)Bereitgestellt von

Damit verzögern wir den Aufruf unseres Event-Handlers um eine Sekunde; anschließend wird er aufgerufen und erhält den Loop als ersten Parameter. Möchtest du einen konkreten Zeitpunkt in der Zukunft planen, nimm die Zeit des Loops statt der Systemzeit. So geht’s:

current_time = loop.time()Bereitgestellt von

Dann kannst du call_at verwenden und die gewünschte Zeit übergeben. Angenommen, wir wollen den Event-Handler in fünf Minuten aufrufen. So könnte das aussehen:

loop.call_at(current_time + 300, event_handler, loop)Bereitgestellt von

Hier nehmen wir die aktuelle Loop-Zeit und addieren 300 Sekunden bzw. fünf Minuten. So verzögern wir den Aufruf unseres Event-Handlers um fünf Minuten. Ziemlich praktisch!

Tasks

Tasks sind eine Unterklasse von Future und ein Wrapper um eine Coroutine. Sie ermöglichen es dir, nachzuvollziehen, wann die Verarbeitung abgeschlossen ist. Da sie eine Future sind, können andere Coroutinen auf eine Task warten, und du kannst das Ergebnis einer fertig verarbeiteten Task abrufen.

Ein einfaches Beispiel:

import _______

async def my_task(seconds):
    """
    A task to do for a number of seconds
    """
    print('This task is taking {} seconds to complete'.format(
        seconds))
    await asyncio.sleep(_______)
    return 'task finished'
 
 
if __name__ == '__main__':
    my_event_loop = asyncio.get_event_loop()
    try:
        print('task creation started')
        task_obj = my_event_loop.create_task(my_task(seconds=2))
        my_event_loop.run_until_complete(task_obj)
    finally:
        my_event_loop._____()
 
    print("The task's result was: {}".format(task_obj.result()))

Hier definieren wir eine asynchrone Funktion, die die Anzahl der Sekunden entgegennimmt, die sie „laufen“ soll – als Simulation eines lang laufenden Prozesses. Dann erstellen wir den Event-Loop und erzeugen mit dessen create_task eine Task. create_task nimmt die Funktion entgegen, die wir als Task ausführen wollen. Anschließend lassen wir den Event-Loop laufen, bis die Task abgeschlossen ist. Am Ende holen wir uns das Ergebnis der Task.

Tasks lassen sich außerdem sehr leicht mit ihrer cancel-Methode abbrechen. Ruf sie einfach auf, wenn du eine Task beenden willst. Wird eine Task während des Wartens auf eine andere Operation abgebrochen, wirft sie eine CancelledError.

Fazit

Jetzt kennst du genug, um mit der Bibliothek asyncio eigenständig zu arbeiten. asyncio ist sehr mächtig und ermöglicht dir eine Menge spannender Aufgaben. Die asyncio-Bibliothek wurde für Netzwerksockets konzipiert.

Eine großartige Bibliothek für asynchrones Socket-Programming vor asyncio ist das Twisted-Framework. Ein weiteres spannendes Projekt ist Dask, eine flexible Bibliothek für paralleles Rechnen in der Analytik. Stöbere in der Dokumentation zum asyncio-Modul und lass deinen Ideen freien Lauf!