So führen Sie zwei asynchrone Funktionen für immer in Python aus

Asynchrone Funktionen, auch Coroutinen genannt, sind Funktionen, die während der Ausführung angehalten und fortgesetzt werden können. In Python bietet das Asyncio-Modul ein leistungsstarkes Framework zum Schreiben von gleichzeitigem Code mithilfe von Coroutinen, bei denen es sich um spezielle Funktionen handelt, die angehalten und fortgesetzt werden können. In diesem Artikel erfahren Sie, wie Sie mithilfe von Asyncio zwei asynchrone Funktionen für immer in Python ausführen.

Asynchrone Funktion

Asynchrone Funktionen, auch Coroutinen genannt, sind Funktionen, die während der Ausführung angehalten und fortgesetzt werden können. Sie ermöglichen die gleichzeitige Ausführung von Code, ohne den Hauptthread zu blockieren, und ermöglichen so eine effiziente Nutzung der Systemressourcen.

Um eine asynchrone Funktion in Python zu definieren, verwenden wir das Schlüsselwort async vor der def-Anweisung. In einer asynchronen Funktion können wir das Schlüsselwort „await“ verwenden, um die Ausführung anzuhalten und auf den Abschluss einer anderen asynchronen Funktion oder Coroutine zu warten.

Methode 1 – Asyncio-Modul verwenden

Das Asyncio-Modul in Python bietet ein Framework zum Schreiben von gleichzeitigem Single-Thread-Code mithilfe von Coroutinen, zum Multiplexen des E/A-Zugriffs über Sockets und andere Ressourcen, zum Ausführen von Netzwerk-Clients und -Servern sowie für andere damit verbundene Vorgänge. Es ermöglicht uns, asynchronen Code strukturiert und organisiert zu schreiben.

Grammatik

Here, the asyncio.get_event_loop() function is used to retrieve the current event loop or create a new one if none exists.

Beispiel

Im Beispiel für Funktion 1 unten haben wir eine Endlosschleife, die „Funktion 1“ ausgibt und dann mit „await asyncio.sleep(1)“ eine Sekunde lang pausiert. Ebenso verfügt Funktion2 über eine Endlosschleife, die „Funktion 2“ ausgibt und 2 Sekunden lang pausiert. Durch den Aufruf von asyncio.gather(function1(), function2()) in der Hauptfunktion weisen wir die Ereignisschleife an, beide Funktionen gleichzeitig auszuführen. Die Funktion asyncio.gather ist für die verschachtelte Planung und Ausführung dieser beiden Funktionen verantwortlich. Wenn wir das Python-Skript ausführen, läuft die Ereignisschleife unbegrenzt und führt wiederholt Funktion1 und Funktion2 aus. Die Ausgabe zeigt dieses Verhalten, wobei Nachrichten von beiden Funktionen basierend auf ihren jeweiligen Zeitintervallen verschachtelt gedruckt werden.

import asyncio

async def function1():
    while True:
        print("Function 1")
        await asyncio.sleep(1)  # Pause execution for 1 second

async def function2():
    while True:
        print("Function 2")
        await asyncio.sleep(2)  # Pause execution for 2 seconds

async def main():
    await asyncio.gather(function1(), function2())

if __name__ == "__main__":
    loop = asyncio.get_event_loop()
    try:
        loop.run_until_complete(main())
    finally:
        loop.close()

Ausgabe

Function 1
Function 2
Function 1
Function 2
Function 1
Function 1
Function 2
Function 1
Function 1
.
.
.

Methode 1 – Threads verwenden

Threads sind leichtgewichtig und ermöglichen die gleichzeitige Ausführung mehrerer Aufgaben in einem einzigen Prozess. Bei dieser Methode verwenden wir das Thread-Modul, um zwei asynchrone Funktionen für immer auszuführen.

Grammatik

thread1 = threading.Thread(target=async_function1)

Beispiel

Im folgenden Beispiel haben wir zwei asynchrone Funktionen: async_function1 und async_function2.

• async_function1 verwendet time.sleep(1), um jede Sekunde „Async function 1“ zu drucken.

• async_function2 verwendet time.sleep(2), um alle zwei Sekunden „Async function 2“ zu drucken.

Wir erstellen zwei Threads, Thread1 und Thread2, für async_function1 bzw. async_function2. Die Thread-Klasse im Thread-Modul wird zum Erstellen und Verwalten von Threads verwendet. Dann starten wir zwei Threads mit der Methode start(). Dadurch wird die Ausführung asynchroner Funktionen in separaten Threads gestartet, sodass diese gleichzeitig ausgeführt werden können.

import threading
import time

def async_function1():
    while True:
        print("Async function 1")
        time.sleep(1)

def async_function2():
    while True:
        print("Async function 2")
        time.sleep(2)

thread1 = threading.Thread(target=async_function1)
thread2 = threading.Thread(target=async_function2)

thread1.start()
thread2.start()

while True:
    pass

Ausgabe

Die Ausgabe dieses Beispiels gibt kontinuierlich jede Sekunde „Async-Funktion 1“ und alle zwei Sekunden „Async-Funktion 2“ aus. Dieser Code startet zwei Threads, von denen jeder seine eigene asynchrone Funktion ausführt. Der Hauptthread wird durch eine Endlosschleife am Leben gehalten, damit andere Threads unbegrenzt ausgeführt werden können.

Async function 1
Async function 1
Async function 2
Async function 1
Async function 1
Async function 2
Async function 1
Async function 1
Async function 2

Methode 3 – Unterprozess verwenden

Unterprozesse sind unabhängige Prozesse, die in Python-Programmen erstellt und verwaltet werden können. Bei dieser Methode verwenden wir das Unterprozessmodul, um zwei asynchrone Funktionen für immer auszuführen.

Grammatik

subprocess.Popen(args, bufsize=-1, executable=None)

Hier,

• args (erforderlich): Dieser Parameter gibt den auszuführenden Befehl an. Es kann eine Zeichenfolge oder eine Folge von Zeichenfolgen sein.

• bufsize: Dieser Parameter stellt die Puffergröße dar, die für E/A-Vorgänge verwendet wird. Der Standardwert ist -1, was bedeutet, dass die Standardpuffergröße des Systems verwendet wird.

• bufsize: Dieser Parameter stellt die Puffergröße dar, die für E/A-Vorgänge verwendet wird. Der Standardwert ist -1, was bedeutet, dass die Standardpuffergröße des Systems verwendet wird.

Beispiel

In diesem Beispiel haben wir zwei identische asynchrone Funktionen: async_function1 und async_function2.

• async_function1 verwendet time.sleep(1), um jede Sekunde „Async function 1“ zu drucken.

• async_function2 verwendet time.sleep(2), um alle zwei Sekunden „Async function 2“ zu drucken.

Wir verwenden die Klasse subprocess.Popen im Subprocess-Modul, um Unterprozesse anstelle von Threads zu erstellen. Jeder untergeordnete Prozess wird durch die Ausführung eines separaten Python-Prozesses erstellt, der die entsprechende asynchrone Funktion ausführt. Der Unterprozess wird mit dem Konstruktor subprocess.Popen erstellt und wir übergeben den Python-Befehl, um die erforderliche Funktion auszuführen. Beispielsweise führt ['python', '-c', 'from module import async_function1; async_function1()'] async_function1 von einem separaten Python-Prozess aus.

import subprocess
import time

def async_function1():
    while True:
        print("Async function 1")
        time.sleep(1)

def async_function2():
    while True:
        print("Async function 2")
        time.sleep(2)

subprocess1 = subprocess.Popen(['python', '-c', 'from module import async_function1; async_function1()'])
subprocess2 = subprocess.Popen(['python', '-c', 'from module import async_function2; async_function2()'])

while True:
    pass

Ausgabe

Die Ausgabe dieses Beispiels gibt kontinuierlich jede Sekunde „Async-Funktion 1“ und alle zwei Sekunden „Async-Funktion 2“ aus. Dieser Code erstellt zwei untergeordnete Prozesse, von denen jeder seine eigene asynchrone Funktion ausführt. Der Hauptprozess wird über eine Endlosschleife am Leben gehalten, damit untergeordnete Prozesse unbegrenzt ausgeführt werden können.

Async function 1
Async function 1
Async function 2
Async function 1
Async function 1
Async function 2
Async function 1
Async function 1
Async function 2

结论

在本文中，我们讨论了如何使用 Python 中的 asyncio 模块在 Python 中永久运行两个异步函数。使用 asyncio 进行异步编程为编写高性能和响应式 Python 应用程序开辟了新的可能性。通过利用异步函数和事件循环，您可以利用并发的力量并有效地管理多个任务。

Das obige ist der detaillierte Inhalt vonSo führen Sie zwei asynchrone Funktionen für immer in Python aus. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!