Comment utiliser les fonctions communes asyncio de Python ?

La définition de la coroutine

Vous devez utiliser l'instruction def asynchrone

Ce que la coroutine peut faire :

1 Attendre un résultat futur

2. Attendre une autre coroutine (produire un résultat ou déclencher une exception)

3. , générez un résultat pour la coroutine qui l'attend

4. Lancez une exception à la coroutine qui l'attend

Exécution de la coroutine

Appelez la fonction coroutine, la coroutine ne commencera pas à s'exécuter, mais reviendra simplement un objet coroutine

Il existe deux façons de laisser l'objet coroutine s'exécuter :

1 Utilisez await pour l'attendre dans une autre coroutine déjà en cours d'exécution 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

2 Via ensure_future</code. >La fonction planifie son exécution<p></p>Ce n'est que lorsque la boucle d'un certain thread est en cours d'exécution que la coroutine peut s'exécuter<p></p>L'exemple suivant :<h3></h3>Obtenez d'abord la boucle par défaut du thread actuel, puis transmettez l'objet coroutine à boucler. run_until_complete, L'objet coroutine sera alors exécuté dans la boucle<p><div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:py;">loop.run_until_complete(asyncio.gather(do_some_work(1), do_some_work(3)))</pre><div class="contentsignin">Copier après la connexion</div></div></p><code>run_until_complete est un appel bloquant il ne reviendra que lorsque la coroutine sera terminée. Son paramètre est un futur, mais ce qu'on lui passe. is L'objet coroutine est vérifié en interne et l'objet coroutine est empaqueté dans un futur via la fonction Ensure_future

Nous pouvons écrire comme ceci :

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))

Plusieurs coroutines en cours d'exécution

Plusieurs coroutines s'exécutent en boucle, afin de remettre plusieurs coroutines à la boucle, vous devez utiliser la fonction asyncio.gathre

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()

ou enregistrer d'abord les objets coroutine dans la liste. C'est plus courant

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))  # 此处异常

gather joue le rôle d'agrégation de futurs multiples. sont regroupés dans un seul futur car loop.run_until_complete n'accepte qu'un seul futur.

À propos de loop.close()

Pour faire simple, tant que la boucle n'est pas fermée, elle peut toujours s'exécuter. :

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)

Mais s'il est fermé, il ne peut plus fonctionner :

asyncio.get_running_loop() # 返回当前os线程中正在运行的事件循环
asyncio.get_event_loop() # 获取当前事件循环
asyncio.set_event_loop(loop) # 获取当前事件循环
asyncio.new_event_loop() # 创建并返回一个新的事件循环对象

Callback

Rejoindre la coroutine est une opération de lecture IO Une fois la lecture des données terminée, nous espérons être avertis pour la prochaine étape du traitement des données. . Cela peut être implémenté en ajoutant des rappels au futur

loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)

Boucle d'événements

• La boucle d'événements exécutera des tâches et des rappels asynchrones, effectuera des opérations d'E/S réseau et exécutera des processus enfants
  D'après le document de politique de boucle d'événements asyncio, nous savons que le La politique de boucle d'événements est un objet global de processus qui contrôle la gestion de toutes les boucles d'événements du processus.
• La politique globale du processus définit la signification du contexte contrôlé par la politique et gère des boucles d'événements distinctes dans chaque contexte. Le contexte défini par la politique par défaut est le thread actuel, ce qui signifie que différents threads sont donc des contextes différents. il existe différentes boucles d'événements.
  Obtenir la boucle d'événement
rrreee

asyncio.get_event_loop()

Si : 🎜🎜🎜🎜Le fil actuel est le fil principal🎜🎜🎜🎜Le fil actuel ne démarre pas la boucle d'événement🎜🎜🎜🎜Appeler un syncio .get_event_loop ()Method meeting Générez une nouvelle boucle d'événements par défaut et définissez-la comme boucle d'événements du thread actuel. 🎜🎜À l'heure actuelle, get_event_loop() équivaut à : 🎜rrreee

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!