Phenquestions
Koroutine: Der Teil des Codes, der in Multithread-Skripten angehalten und fortgesetzt werden kann, wird als Coroutine bezeichnet. Coroutinen arbeiten kooperativ in Multithread-Programmen. Wenn eine Coroutine pausiert, kann eine andere Coroutine ausgeführt werden.
Ereignisschleife: Es wird verwendet, um die Ausführung von Coroutinen zu starten und Ein-/Ausgabeoperationen abzuwickeln. Es braucht mehrere Aufgaben und erledigt sie.
Aufgabe: Die Ausführung und das Ergebnis von Coroutinen werden durch die Tasks definiert. Sie können mit der asyncio-Bibliothek mehrere Aufgaben zuweisen und die Aufgaben asynchron ausführen.
Zukunft: Es fungiert als zukünftiger Speicher, in dem das Ergebnis von Coroutinen nach Abschluss gespeichert wird. Dies ist nützlich, wenn eine Coroutine auf das Ergebnis einer anderen Coroutine warten muss.
Wie Sie die oben genannten Konzepte der asyncio-Bibliothek implementieren können, wird in diesem Tutorial anhand einiger einfacher Beispiele gezeigt.
Beispiel-1: Erstellen einer einzelnen Coroutine mit einer einzelnen Aufgabe
Erstellen Sie eine Datei mit dem Namen asynchron1.py und füge den folgenden Code hinzu. asyncio-Bibliothek wird importiert, um die Funktionen dieser Bibliothek zu nutzen. hinzufügen Funktion ist deklariert, um die Summe eines bestimmten Zahlenbereichs zu berechnen. Der Nummernbereich von 1 bis 101 wird von der Task mit einer Sekunde Verzögerung vergeben. Die Ereignisschleife wird so deklariert, dass sie ausgeführt wird, bis alle Aufgaben der Hauptmethode abgeschlossen sind. Nach der Berechnung des Wertes wartet die Funktion eine Sekunde und druckt das Ergebnis.
Asyncio importierenasync def add(start,end,wait):
#Summenvariable initialisieren
Summe = 0
#Berechnen Sie die Summe aller Zahlen
für n im Bereich (Anfang, Ende):
Summe += n
#Warten Sie auf zugewiesene Sekunden
asyncio erwarten.schlafen (warte)
#Drucken Sie das Ergebnis aus
print(f'Summe von start bis end ist sum')
async def main():
#Eine einzelne Aufgabe zuweisen
Aufgabe=Schleife.create_task(add(1,101,1))
#Aufgabe asynchron ausführen
asyncio erwarten.warten ([Aufgabe])
if __name__ == '__main__':
#Ereignisschleife deklarieren
Schleife = asyncio.get_event_loop()
#Führe den Code aus, bis alle Aufgaben abgeschlossen sind
Schleife.run_until_complete(main())
#Schließen Sie die Schleife
Schleife.schließen()
Ausgabe:
$ python3 async1.pyDie Ausgabe zeigt die Summe von 1 bis 101, die 5050 ist.
Beispiel-2: Mehrere Coroutinen erstellen
Die Verwendung der asyncio-Bibliothek wird gelöscht, wenn Sie mehrere Coroutinen gleichzeitig ausführen. Erstellen Sie eine neue Datei mit dem Namen asynchron2.py und füge den folgenden Code hinzu. Es werden drei Aufgaben mit drei unterschiedlichen Bereichen und Wartewerten in . generiert Main() Methode. Die erste Aufgabe berechnet die Summe von 5 bis 500000, indem sie 3 Sekunden wartet, die zweite Aufgabe berechnet die Summe von 2 bis 300000, indem sie 2 Sekunden wartet, und die dritte Aufgabe berechnet die Summe von 10 bis 1000, indem sie 1 Sekunden wartet. Die Aufgabe mit niedrigen Wartewerten wird zuerst abgeschlossen und die Aufgabe mit hohem Wartewert wird zuletzt abgeschlossen.
Asyncio importierenasync def add(start,end,wait):
#Summenvariable initialisieren
Summe = 0
#Berechnen Sie die Summe aller Zahlen
für n im Bereich (Anfang, Ende):
Summe += n
#Warten Sie auf zugewiesene Sekunden
asyncio erwarten.schlafen (warte)
#Drucken Sie das Ergebnis aus
print(f'Summe von start bis end ist sum')
async def main():
#Erste Aufgabe zuweisen
task1=Schleife.create_task(add(5.500.000,3))
#Zweite Aufgabe zuweisen
task2=Schleife.create_task(add(2.300.000,2))
#Dritte Aufgabe zuweisen
task3=Schleife.create_task(add(10,1000,1))
#Führen Sie die Aufgaben asynchron aus
asyncio erwarten.warten([Aufgabe1,Aufgabe2,Aufgabe3])
if __name__ == '__main__':
#Ereignisschleife deklarieren
Schleife = asyncio.get_event_loop()
#Führe den Code aus, bis alle Aufgaben abgeschlossen sind
Schleife.run_until_complete(main())
#Schließen Sie die Schleife
Schleife.schließen()
Ausgabe:
$ python3 async1.pyDie Ausgabe zeigt an, dass Task3 zuerst abgeschlossen wird, da die Wartezeit dieser Task nur 1 Sekunde betrug und Task1 zuletzt abgeschlossen wird, da die Wartezeit dieser Task 3 Sekunden betrug.
Beispiel-3: Koroutinen mit Future
Dieses Beispiel zeigt die Verwendung des zukünftigen Objekts der asyncio-Bibliothek. Erstellen Sie eine neue Datei mit dem Namen asynchron3.py und füge den folgenden Code hinzu. In diesem Beispiel sind zwei Aufgaben für die Zukunft zugewiesen. zeige Nachricht Hier wird die Funktion deklariert, um die Nachricht vor der Ausführung der Coroutine und nach Abschluss der Ausführung zu drucken. Die erste Aufgabe wartet 2 Sekunden und wird zuletzt abgeschlossen. Zweite Aufgabe wartet 1 Sekunde und wird zuerst abgeschlossen.
Asyncio importierenasync def show_message(number,wait):
#Drucken Sie die Nachricht
print(f'Aufgabe Nummer wird ausgeführt')
#Warten Sie auf zugewiesene Sekunden
asyncio erwarten.schlafen (warte)
print(f'Aufgabe Nummer ist abgeschlossen')
async def stop_after (wenn):
asyncio erwarten.schlafen (wann)
Schleife.Stopp()
async def main():
#Erste Aufgabe zuweisen
task1=asyncio.sichere_zukunft(show_message(1,2))
print('Zeitplan 1')
#Zweite Aufgabe zuweisen
task2=asyncio.sichere_zukunft(show_message(2,1))
print('Zeitplan 2')
#Führen Sie die Aufgaben asynchron aus
asyncio erwarten.warten([Aufgabe1,Aufgabe2])
if __name__ == '__main__':
#Ereignisschleife deklarieren
Schleife = asyncio.get_event_loop()
#Führen Sie den Code der Hauptmethode aus, bis alle Aufgaben abgeschlossen sind
Schleife.run_until_complete(main())
Ausgabe:
$ python3 async3.pyIn der Ausgabe wird angezeigt, dass Task1 zuerst gestartet und zuletzt abgeschlossen wird und Task2 später gestartet, aber für kurze Wartezeit zuerst abgeschlossen wird.
Fazit
Das Grundkonzept der asynchronen Programmierung mit der asyncio-Bibliothek von Python wird hier erklärt. Ich hoffe, Sie werden in der Lage sein, Multithread-Code in Python zu schreiben, nachdem Sie die Beispiele dieses Tutorials geübt haben.
