Wie verwende ich die allgemeinen Asyncio-Funktionen von Python?

Die Definition von Coroutine

Sie müssen eine asynchrone Def-Anweisung verwenden

Was Coroutine tun kann:

1 Warten Sie auf ein anderes Coroutine (Erzeugen eines Ergebnisses oder Auslösen einer Ausnahme)

3 , Generieren Sie ein Ergebnis für die Coroutine, die darauf wartet

4. Wirf eine Ausnahme für die Coroutine, die darauf wartet ein Coroutine-Objekt

Es gibt zwei Möglichkeiten, das Coroutine-Objekt laufen zu lassen:

1. Verwenden Sie await, um in einer anderen bereits laufenden Coroutine darauf zu warten

2 >Die Funktion plant ihre Ausführung

Nur wenn die Schleife eines bestimmten Threads ausgeführt wird, kann die Coroutine ausgeführt werden

Das folgende Beispiel:await等待它

2、通过ensure_future函数计划它的执行

只有某线程的loop运行了，协程才可能运行

下面的例子：

先拿到当前线程缺省的loop，然后将协程对象交给loop.run_until_complete,协程对象随后会在loop里得到运行

loop = asyncio.get_event_loop()
loop.run_until_complete(do_some_work(3))

run_until_complete是一个阻塞调用，知道协程运行结束才返回

它的参数是一个future，但是我们传给它的却是协程对象，它在内部做了检查，通过ensure_future函数把协程对象包装成了future

我们可以这样写：

loop.run_until_complete(asyncio.ensure_future(do_some_work(3)))

多个协程运行

多个协程在一个loop里运行，为了把多个协程交给loop，需要借助asyncio.gathre

Erstens die Standardschleife des aktuellen Threads abrufen und dann das Coroutine-Objekt an die Schleife übergeben. run_until_complete, Das Coroutine-Objekt wird dann in der Schleife ausgeführt. run_until_complete ist ein blockierender Aufruf. Es wird nicht zurückgegeben, bis die Coroutine fertig ist, sondern das, was wir an sie übergeben ist Das Coroutine-Objekt wird intern überprüft und das Coroutine-Objekt wird über die Funktion „sure_future“ in eine Zukunft gepackt. Wir können so schreiben: Um Coroutinen in die Schleife einzufügen, müssen Sie die Funktion asyncio.gathre verwenden oder zuerst die Coroutine-Objekte in der Liste speichern. Dies ist häufiger der Fall. Gather spielt die Rolle der Aggregation werden in einen einzelnen Future verpackt, da loop.run_until_complete nur einen einzelnen Future akzeptiert.

Über loop.close()

Einfach ausgedrückt: Solange die Schleife nicht geschlossen ist, kann sie trotzdem ausgeführt werden. :

loop.run_until_complete(asyncio.gather(do_some_work(1), do_some_work(3)))

Aber wenn es geschlossen ist, kann es nicht mehr ausgeführt werden:

loop = asyncio.get_event_loop() #获取当前线程loop
coros_list = []
for i in range(2000):
    coros_list.append(main(i))
loop.run_until_complete(asyncio.gather(*coros_list))

Rückruf

Der Beitritt zur Coroutine ist ein IO-Lesevorgang. Nachdem das Lesen der Daten abgeschlossen ist, werden wir hoffentlich über den nächsten Schritt der Datenverarbeitung benachrichtigt . Dies kann durch Hinzufügen von Rückrufen zur Zukunft implementiert werden

loop = asyncio.get_event_loop() #获取当前线程loop
loop.run_until_complete(do_some_work(loop, 1))
loop.run_until_complete(do_some_work(loop, 3))
loop.close()

Ereignisschleife

Die Ereignisschleife führt asynchrone Aufgaben und Rückrufe aus, führt Netzwerk-E/A-Vorgänge aus und führt untergeordnete Prozesse aus

Aus dem Richtliniendokument für asynchrone Ereignisschleifen wissen wir, dass die Die Ereignisschleifenrichtlinie ist ein globales Prozessobjekt, das die Verwaltung aller Ereignisschleifen im Prozess steuert.

Die globale Richtlinie des Prozesses definiert die Bedeutung des von der Richtlinie gesteuerten Kontexts und verwaltet separate Ereignisschleifen in jedem Kontext. Der durch die Standardrichtlinie definierte Kontext ist der aktuelle Thread, was bedeutet, dass verschiedene Threads unterschiedliche Kontexte sind Es gibt verschiedene Ereignisschleifen.

Ereignisschleife abrufen

loop = asyncio.get_event_loop() #获取当前线程loop
loop.run_until_complete(do_some_work(loop, 1))
loop.close()
loop.run_until_complete(do_some_work(loop, 3))  # 此处异常

asyncio.get_event_loop()

Wenn:

Der aktuelle Thread ist der Hauptthread

• Der aktuelle Thread startet das Ereignis nicht. Schleife

• C alles asynchron .get_event_loop ()Methodentreffen Generieren Sie eine neue Standardereignisschleife und legen Sie sie als Ereignisschleife des aktuellen Threads fest.

Zu diesem Zeitpunkt entspricht get_event_loop():

def done_callback(futu):
    print('Done')
futu = asyncio.ensure_future(do_some_work(3))
futu.add_done_callback(done_callback)
loop.run_until_complete(futu)

Das obige ist der detaillierte Inhalt vonWie verwende ich die allgemeinen Asyncio-Funktionen von Python?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!