Asynchrone Programmierung ist ein Programmierparadigma, das es ermöglicht, viele Prozesse gleichzeitig und unabhängig voneinander auszuführen, ohne auf den Abschluss eines Prozesses warten zu müssen, bevor mit dem nächsten fortgefahren wird. In diesem Blogbeitrag werden wir uns ansehen, was asynchrone Programmierung ist und wie man sie in Python verwendet.

Was ist asynchrone Programmierung?

Bei der synchronen Programmierung führt der Computer Anweisungen in sequentieller Reihenfolge aus und blockiert die Ausführung, bis ein Job abgeschlossen ist, bevor er mit dem nächsten fortfährt.
Die asynchrone Programmierung hingegen ermöglicht es dem Programm, einen Vorgang zu beginnen und dann mit einem anderen fortzufahren, ohne die Ausführung anzuhalten, bis die ursprüngliche Aufgabe abgeschlossen ist.

Asynchrone Programmierung ist besonders dann von Vorteil, wenn Prozesse wie Netzwerk-E/A oder Datenbankvorgänge lange dauern können. Asynchrone Programmierung kann dazu beitragen, die Leistung und Reaktionsfähigkeit von Softwareanwendungen zu steigern, indem sie es dem Programm ermöglicht, mit anderen Aktivitäten fortzufahren, während es auf den Abschluss eines langsamen Vorgangs wartet.

Abhängig von der verwendeten Programmiersprache und dem verwendeten Framework kann die asynchrone Programmierung mithilfe verschiedener Strategien wie Rückrufen, Versprechen oder Schlüsselwörtern „async/await“ durchgeführt werden.

Unterschiede zwischen asynchroner Programmierung und Mehrfachverarbeitung

Der Hauptunterschied zwischen asynchroner Programmierung und Multiprocessing besteht darin, dass die asynchrone Programmierung nicht blockierende Vorgänge innerhalb eines einzelnen Threads ermöglicht, während Multiprocessing viele Kerne oder Prozesse verwendet , um die Arbeit gleichzeitig abzuschließen.

Unterschiede zwischen asynchroner Programmierung und Threading

Der Hauptunterschied zwischen asynchroner Programmierung und Threading besteht darin, dass die asynchrone Programmierung nicht blockierende Vorgänge durch die Verwendung eines einzelnen Threads ermöglicht, während Threading mehrere Threads verwendet, um mehrere Aufgaben parallel auszuführen .

Weitere Informationen zu den Unterschieden: Treading vs. Multiprocessing vs. asynchrone Programmierung

Wie verwende ich Asyncio?

Lassen Sie uns zunächst ein einfaches Programm erstellen, das mit der Ausführung einer Aufgabe beginnt und diese beendet.

import time
import asyncio

def do_job(s):
    print(f"{s} started")
    await asyncio.sleep(1)
    print(f"{s} done")

def main():
    start = time.perf_counter()
    todo = ["Job A", "Job B", "Job C"]
    for job in todo:
        do_job(job)
    
    end = time.perf_counter()
    print(f"Took: {end-start:.3f} seconds")

main()

# OUTPUT
# Job A started
# Job Adone
# Job B started
# Job B done
# Job C started
# Job C done
# Took: 3.009 seconds

Coroutinen erstellen und ausführen

Eine Coroutine ist eine Art Funktion, die während der Ausführung zu verschiedenen Zeitpunkten unterbrochen und wieder aufgenommen werden kann. Mit anderen Worten: Eine Coroutine ermöglicht es Ihnen, Code zu schreiben, der unterbrochen werden kann, etwas anderes zu tun und dann dort fortzufahren, wo er aufgehört hat.

Zum Erstellen von Coroutinen müssen wir das asyncSchlüsselwort vor dem defSchlüsselwort verwenden. Durch den Aufruf einer Coroutine wird nicht die Funktion aufgerufen, die wir ausführen möchten. Es erstellt eine Aufgabe.

import time
import asyncio

async def do_job(s):
  ...

async def main():
  ...

main()

asyncio.run(main())

Wenn Sie diesen Code ausführen, erhalten Sie wahrscheinlich eine Fehlermeldung wie diese:

RuntimeWarning: coroutine '...' was never awaited

import time
import asyncio

async def do_job(s):
    print(f"{s} started")
    await asyncio.sleep(1)
    print(f"{s} done")

async def main():
    start = time.perf_counter()
    todo = ["Job A", "Job B", "Job C"]
    for job in todo:
        await do_job(job)
    
    end = time.perf_counter()
    print(f"Took: {end-start:.3f} seconds")

asyncio.run(main())

# OUTPUT
# Job A started
# Job A done
# Job B started
# Job B done
# Job C started
# Job C done
# Took: 3.009 seconds

await asyncio.sleep(1)

tasks = [asyncio.create_task(do_job(item)) for item in todo]
done, pending = await asyncio.wait(tasks)

import time
import asyncio

async def do_job(s):
    print(f"{s} started")
    await asyncio.sleep(1)
    print(f"{s} done")

async def main():
    start = time.perf_counter()
    todo = ["Job A", "Job B", "Job C"]
    
    tasks = [asyncio.create_task(do_job(item)) for item in todo]
    done, pending = await asyncio.wait(tasks)
    
    end = time.perf_counter()
    print(f"Took: {end-start:.3f} seconds")

asyncio.run(main())

# OUTPUT
# Job A started
# Job B started
# Job C started
# Job A done
# Job B done
# Job C done
# Took: 1.009 seconds

Weitere Informationen zur asynchronen Programmierung in Python finden Sie im Video. ( Einführung in asynchrones Python | Schreiben eines Webcrawlers )