Hochleistungs-Python: Asyncio

Parallelitätsprogrammierung ist ein Programmieransatz, der sich mit der gleichzeitigen Ausführung mehrerer Aufgaben befasst. In Python ist asyncio ein leistungsstarkes Tool zur Implementierung asynchroner Programmierung. Basierend auf dem Konzept von Coroutinen kann Asyncio E/A-intensive Aufgaben effizient bewältigen. In diesem Artikel werden die Grundprinzipien und die Verwendung von Asyncio vorgestellt.

Warum wir Asyncio brauchen

Wir wissen, dass die Verwendung von Multithreading bei der Verarbeitung von E/A-Vorgängen die Effizienz im Vergleich zu einem normalen Einzelthread erheblich verbessern kann. Warum brauchen wir also immer noch Asyncio?

Multithreading hat viele Vorteile und ist weit verbreitet, weist aber auch gewisse Einschränkungen auf:

• Zum Beispiel wird der laufende Prozess des Multithreadings leicht unterbrochen, sodass die Situation einer Race Condition auftreten kann.
• Darüber hinaus ist der Threadwechsel selbst mit gewissen Kosten verbunden und die Anzahl der Threads kann nicht unbegrenzt erhöht werden. Wenn Ihre E/A-Vorgänge daher sehr umfangreich sind, wird Multithreading die Anforderungen an hohe Effizienz und hohe Qualität wahrscheinlich nicht erfüllen.

Genau um diese Probleme zu lösen, ist Asyncio entstanden.

Synchronisieren vs. asynchron

Unterscheiden wir zunächst zwischen den Konzepten Sync (synchron) und Async (asynchron).

• Synchronisieren bedeutet, dass Vorgänge nacheinander ausgeführt werden. Der nächste Vorgang kann erst ausgeführt werden, nachdem der vorherige abgeschlossen ist.
• Asynchron bedeutet, dass verschiedene Vorgänge abwechselnd ausgeführt werden können. Wenn einer der Vorgänge blockiert ist, wartet das Programm nicht, sondern findet ausführbare Vorgänge, um fortzufahren.

So funktioniert Asyncio

1. Coroutinen: Asyncio verwendet Coroutinen, um asynchrone Operationen zu erreichen. Eine Coroutine ist eine spezielle Funktion, die mit dem Schlüsselwort async definiert wird. In einer Coroutine kann das Schlüsselwort „await“ verwendet werden, um die Ausführung der aktuellen Coroutine anzuhalten und auf den Abschluss einer asynchronen Operation zu warten.
2. Ereignisschleife: Die Ereignisschleife ist einer der Kernmechanismen von Asyncio. Es ist für die Planung und Ausführung von Coroutinen sowie für den Wechsel zwischen Coroutinen verantwortlich. Die Ereignisschleife fragt ständig nach ausführbaren Aufgaben ab. Sobald eine Aufgabe bereit ist (z. B. wenn ein E/A-Vorgang abgeschlossen ist oder ein Timer abläuft), wird sie von der Ereignisschleife in die Ausführungswarteschlange gestellt und mit der nächsten Aufgabe fortgefahren.
3. Asynchrone Aufgaben: Bei Asyncio führen wir Coroutinen aus, indem wir asynchrone Aufgaben erstellen. Asynchrone Aufgaben werden von der Funktion asyncio.create_task() erstellt, die die Coroutine in ein erwartbares Objekt kapselt und es zur Verarbeitung an die Ereignisschleife übermittelt.
4. Asynchrone E/A-Operationen: Asyncio bietet eine Reihe asynchroner E/A-Operationen (wie Netzwerkanforderungen, Lesen und Schreiben von Dateien usw.), die nahtlos in Coroutinen und die Ereignisschleife integriert werden können Warten Sie auf das Schlüsselwort. Durch die Verwendung asynchroner E/A-Vorgänge kann eine Blockierung während des Wartens auf den E/A-Abschluss vermieden werden, wodurch die Programmleistung und Parallelität verbessert werden.
5. Rückrufe: asyncio unterstützt auch die Verwendung von Rückruffunktionen, um die Ergebnisse asynchroner Vorgänge zu verarbeiten. Die Funktion asyncio.ensure_future() kann verwendet werden, um die Rückruffunktion in ein erwartbares Objekt zu kapseln und es zur Verarbeitung an die Ereignisschleife zu senden.
6. Gleichzeitige Ausführung: Asyncio kann mehrere Coroutine-Aufgaben gleichzeitig ausführen. Die Ereignisschleife plant automatisch die Ausführung von Coroutinen entsprechend der Bereitschaft der Aufgaben und ermöglicht so eine effiziente gleichzeitige Programmierung.

Zusammenfassend basiert das Funktionsprinzip von Asyncio auf den Mechanismen von Coroutinen und Ereignisschleifen. Durch die Verwendung von Coroutinen für asynchrone Operationen und die Verantwortung für die Planung und Ausführung von Coroutinen durch die Ereignisschleife realisiert Asyncio ein effizientes asynchrones Programmiermodell.

Coroutinen und asynchrone Programmierung

Coroutinen sind ein wichtiges Konzept in Asyncio. Es handelt sich um leichtgewichtige Ausführungseinheiten, die schnell zwischen Aufgaben wechseln können, ohne dass der Aufwand für den Thread-Wechsel anfällt. Coroutinen können mit dem Schlüsselwort „async“ definiert werden. Das Schlüsselwort „await“ wird verwendet, um die Ausführung der Coroutine anzuhalten und nach Abschluss eines bestimmten Vorgangs fortzusetzen.

Hier ist ein einfacher Beispielcode, der zeigt, wie Coroutinen für die asynchrone Programmierung verwendet werden:

import asyncio

async def hello():
    print("Hello")
    await asyncio.sleep(1)  # Simulate a time-consuming operation
    print("World")

# Create an event loop
loop = asyncio.get_event_loop()

# Add the coroutine to the event loop and execute
loop.run_until_complete(hello())

In diesem Beispiel ist die Funktion hello() eine Coroutine, die mit dem Schlüsselwort async definiert ist. Innerhalb der Coroutine können wir „await“ verwenden, um ihre Ausführung anzuhalten. Hier wird asyncio.sleep(1) verwendet, um einen zeitaufwändigen Vorgang zu simulieren. Die Methode run_until_complete() fügt die Coroutine zur Ereignisschleife hinzu und führt sie aus.

Asynchrone E/A-Operationen

asyncio wird hauptsächlich zur Verarbeitung von E/A-intensiven Aufgaben wie Netzwerkanforderungen, Lesen und Schreiben von Dateien verwendet. Es bietet eine Reihe von APIs für asynchrone E/A-Vorgänge, die in Kombination mit dem Schlüsselwort „await“ verwendet werden können, um auf einfache Weise eine asynchrone Programmierung zu erreichen.

Hier ist ein einfacher Beispielcode, der zeigt, wie man Asyncio für asynchrone Netzwerkanfragen verwendet:

import asyncio
import aiohttp

async def fetch(session, url):
    async with session.get(url) as response:
        return await response.text()

async def main():
    async with aiohttp.ClientSession() as session:
        html = await fetch(session, 'https://www.example.com')
        print(html)

# Create an event loop
loop = asyncio.get_event_loop()

# Add the coroutine to the event loop and execute
loop.run_until_complete(main())

In diesem Beispiel verwenden wir die aiohttp-Bibliothek für Netzwerkanfragen. Die Funktion fetch() ist eine Coroutine. Es initiiert eine asynchrone GET-Anfrage über die Methode session.get() und wartet mit dem Schlüsselwort „await“ auf die Rückgabe der Antwort. Die Funktion main() ist eine weitere Coroutine. Es erstellt darin ein ClientSession-Objekt zur Wiederverwendung und ruft dann die Methode fetch() auf, um den Inhalt der Webseite abzurufen und auszudrucken.

Hinweis: Hier verwenden wir aiohttp anstelle der Requests-Bibliothek, da die Requests-Bibliothek nicht mit asyncio kompatibel ist, die aiohttp-Bibliothek hingegen schon. Um Asyncio sinnvoll nutzen zu können, insbesondere um seine leistungsstarken Funktionen auszuschöpfen, sind in vielen Fällen entsprechende Python-Bibliotheken erforderlich.

Gleichzeitige Ausführung mehrerer Aufgaben

asyncio bietet auch einige Mechanismen zum gleichzeitigen Ausführen mehrerer Aufgaben, wie z. B. asyncio.gather() und asyncio.wait(). Das Folgende ist ein Beispielcode, der zeigt, wie diese Mechanismen verwendet werden, um mehrere Coroutine-Aufgaben gleichzeitig auszuführen:

import asyncio

async def task1():
    print("Task 1 started")
    await asyncio.sleep(1)
    print("Task 1 finished")

async def task2():
    print("Task 2 started")
    await asyncio.sleep(2)
    print("Task 2 finished")

async def main():
    await asyncio.gather(task1(), task2())

# Create an event loop
loop = asyncio.get_event_loop()

# Add the coroutine to the event loop and execute
loop.run_until_complete(main())

In diesem Beispiel definieren wir zwei Coroutine-Aufgaben task1() und task2(), die beide einige zeitaufwändige Vorgänge ausführen. Die Coroutine main() startet diese beiden Aufgaben gleichzeitig über asyncio.gather() und wartet auf deren Abschluss. Die gleichzeitige Ausführung kann die Effizienz der Programmausführung verbessern.

Wie wählt man aus?

Sollten wir in tatsächlichen Projekten Multithreading oder Asyncio wählen? Ein Big Shot hat es anschaulich zusammengefasst:

import asyncio

async def hello():
    print("Hello")
    await asyncio.sleep(1)  # Simulate a time-consuming operation
    print("World")

# Create an event loop
loop = asyncio.get_event_loop()

# Add the coroutine to the event loop and execute
loop.run_until_complete(hello())

• Wenn es E/A-gebunden ist und die E/A-Vorgänge langsam sind und die Zusammenarbeit vieler Aufgaben/Threads erfordern, ist die Verwendung von Asyncio besser geeignet.
• Wenn es E/A-gebunden ist, die E/A-Vorgänge jedoch schnell sind und nur eine begrenzte Anzahl von Aufgaben/Threads benötigt werden, reicht Multithreading aus.
• Wenn es CPU-gebunden ist, ist Mehrfachverarbeitung erforderlich, um die Effizienz der Programmausführung zu verbessern.

Üben

Geben Sie eine Liste ein. Für jedes Element in der Liste möchten wir die Summe der Quadrate aller ganzen Zahlen von 0 bis zu diesem Element berechnen.

Synchrone Implementierung

import asyncio
import aiohttp

async def fetch(session, url):
    async with session.get(url) as response:
        return await response.text()

async def main():
    async with aiohttp.ClientSession() as session:
        html = await fetch(session, 'https://www.example.com')
        print(html)

# Create an event loop
loop = asyncio.get_event_loop()

# Add the coroutine to the event loop and execute
loop.run_until_complete(main())

Die Ausführungszeit beträgt 16,00943413000002 Sekunden

Asynchrone Implementierung mit concurrent.futures

import asyncio

async def task1():
    print("Task 1 started")
    await asyncio.sleep(1)
    print("Task 1 finished")

async def task2():
    print("Task 2 started")
    await asyncio.sleep(2)
    print("Task 2 finished")

async def main():
    await asyncio.gather(task1(), task2())

# Create an event loop
loop = asyncio.get_event_loop()

# Add the coroutine to the event loop and execute
loop.run_until_complete(main())

Die Ausführungszeit beträgt 7,314132894999999 Sekunden

In diesem verbesserten Code verwenden wir concurrent.futures.ProcessPoolExecutor, um einen Prozesspool zu erstellen, und verwenden dann die Methode executor.map(), um Aufgaben zu übermitteln und Ergebnisse zu erhalten. Beachten Sie, dass Sie nach der Verwendung von executor.map(), wenn Sie die Ergebnisse benötigen, die Ergebnisse in einer Liste iterieren oder andere Methoden verwenden können, um die Ergebnisse zu verarbeiten.

Multiprocessing-Implementierung

if io_bound:
    if io_slow:
        print('Use Asyncio')
    else:
        print('Use multi-threading')
elif cpu_bound:
    print('Use multi-processing')

Die Ausführungszeit beträgt 5,024221667 Sekunden

concurrent.futures.ProcessPoolExecutor und multiprocessing sind beide Bibliotheken zur Implementierung der Parallelität mehrerer Prozesse in Python. Es gibt einige Unterschiede:

1. Schnittstellenbasierte Kapselung: concurrent.futures.ProcessPoolExecutor ist eine High-Level-Schnittstelle, die vom Modul concurrent.futures bereitgestellt wird. Es kapselt die zugrunde liegenden Multiprozessfunktionen und erleichtert so das Schreiben von Multiprozesscode. Während Multiprocessing eine der Standardbibliotheken von Python ist, bietet sie vollständige Multiprozessunterstützung und ermöglicht die direkte Bearbeitung von Prozessen.
2. API-Nutzung: Die Verwendung von concurrent.futures.ProcessPoolExecutor ähnelt der eines Thread-Pools. Es sendet aufrufbare Objekte (z. B. Funktionen) zur Ausführung an den Prozesspool und gibt ein Future-Objekt zurück, mit dem das Ausführungsergebnis abgerufen werden kann. Multiprocessing bietet mehr Prozessmanagement- und Kommunikationsschnittstellen auf niedriger Ebene. Prozesse können explizit erstellt, gestartet und gesteuert werden, und die Kommunikation zwischen mehreren Prozessen kann über Warteschlangen oder Pipes erfolgen.
3. Skalierbarkeit und Flexibilität: Da Multiprocessing mehr Low-Level-Schnittstellen bietet, ist es im Vergleich zu concurrent.futures.ProcessPoolExecutor flexibler. Durch die direkte Bedienung von Prozessen kann eine differenziertere Steuerung für jeden Prozess erreicht werden, z. B. das Festlegen von Prozessprioritäten und der Datenaustausch zwischen Prozessen. concurrent.futures.ProcessPoolExecutor eignet sich besser für die einfache Aufgabenparallelisierung, verbirgt viele zugrunde liegende Details und erleichtert das Schreiben von Multiprozesscode.
4. Plattformübergreifende Unterstützung: Sowohl concurrent.futures.ProcessPoolExecutor als auch Multiprocessing bieten plattformübergreifende Multiprozessunterstützung und können auf verschiedenen Betriebssystemen verwendet werden.

Zusammenfassend ist concurrent.futures.ProcessPoolExecutor eine High-Level-Schnittstelle, die die zugrunde liegenden Multiprozessfunktionen kapselt und für die einfache Parallelisierung von Multiprozessaufgaben geeignet ist. Multiprocessing ist eine Bibliothek auf niedrigerer Ebene, die mehr Kontrolle und Flexibilität bietet und für Szenarien geeignet ist, die eine feinkörnige Steuerung von Prozessen erfordern. Sie müssen die geeignete Bibliothek entsprechend den spezifischen Anforderungen auswählen. Wenn es sich nur um eine einfache Aufgabenparallelisierung handelt, können Sie concurrent.futures.ProcessPoolExecutor verwenden, um den Code zu vereinfachen. Wenn mehr Steuerung und Kommunikation auf niedriger Ebene erforderlich sind, können Sie die Multiprocessing-Bibliothek verwenden.

Zusammenfassung

Im Gegensatz zu Multithreading ist Asyncio Single-Threading, aber der Mechanismus seiner internen Ereignisschleife ermöglicht die gleichzeitige Ausführung mehrerer verschiedener Aufgaben und verfügt über eine größere autonome Kontrolle als Multithreading.

Asyncio-Aufgaben werden während des Betriebs nicht unterbrochen, sodass keine Race-Condition-Situation auftritt.

Besonders in Szenarien mit starken E/A-Vorgängen bietet Asyncio eine höhere Betriebseffizienz als Multithreading. Denn die Kosten für den Aufgabenwechsel in Asyncio sind viel geringer als die für Threadwechsel und die Anzahl der Aufgaben, die Asyncio starten kann, ist viel größer als die Anzahl der Threads im Multithreading.

Es ist jedoch zu beachten, dass die Verwendung von Asyncio in vielen Fällen die Unterstützung bestimmter Bibliotheken von Drittanbietern erfordert, wie z. B. aiohttp im vorherigen Beispiel. Und wenn die E/A-Vorgänge schnell und nicht schwer sind, kann die Verwendung von Multithreading das Problem ebenfalls effektiv lösen.

• asyncio ist eine Python-Bibliothek zur Implementierung asynchroner Programmierung.
• Koroutinen sind das Kernkonzept von Asyncio und ermöglichen asynchrone Vorgänge durch die Schlüsselwörter „async“ und „await“.
• asyncio bietet eine leistungsstarke API für asynchrone E/A-Vorgänge und kann problemlos E/A-intensive Aufgaben bewältigen.
• Durch Mechanismen wie asyncio.gather() können mehrere Coroutine-Aufgaben gleichzeitig ausgeführt werden.

---

Leapcell: Die ideale Plattform für FastAPI, Flask und andere Python-Anwendungen

Lassen Sie mich abschließend die ideale Plattform für die Bereitstellung von Flask/FastAPI vorstellen: Leapcell.

Leapcell ist eine Cloud-Computing-Plattform, die speziell für moderne verteilte Anwendungen entwickelt wurde. Das Pay-as-you-go-Preismodell stellt sicher, dass keine Leerlaufkosten anfallen, d. h. Benutzer zahlen nur für die Ressourcen, die sie tatsächlich nutzen.

1. Mehrsprachige Unterstützung
   • Unterstützt die Entwicklung in JavaScript, Python, Go oder Rust.
2. Kostenlose Bereitstellung unbegrenzter Projekte
   • Nur ​​nutzungsbasierte Abrechnung. Keine Gebühr, wenn keine Anfragen vorliegen.
3. Unübertroffene Kosteneffizienz
   • Pay-as-you-go, ohne Leerlaufgebühren.
   • Mit 25 US-Dollar können beispielsweise 6,94 Millionen Anfragen unterstützt werden, mit einer durchschnittlichen Antwortzeit von 60 Millisekunden.
4. Vereinfachte Entwicklererfahrung
   • Intuitive Benutzeroberfläche für einfache Einrichtung.
   • Vollautomatische CI/CD-Pipelines und GitOps-Integration.
   • Echtzeitmetriken und Protokolle, die umsetzbare Erkenntnisse liefern.
5. Mühelose Skalierbarkeit und hohe Leistung
   • Automatische Skalierung zur problemlosen Bewältigung hoher Parallelität.
   • Kein Betriebsaufwand, sodass sich Entwickler auf die Entwicklung konzentrieren können.

Erfahren Sie mehr in der Dokumentation!
Leapcell Twitter: https://x.com/LeapcellHQ

Das obige ist der detaillierte Inhalt vonHochleistungs-Python: Asyncio. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!