Explication détaillée de l'utilisation des coroutines Tornado en Python (avec exemples)

Cet article vous apporte une explication détaillée de l'utilisation des coroutines Tornado en Python (avec des exemples). Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

L'utilisation des coroutines Tornado peut développer un comportement asynchrone similaire au code synchrone. Dans le même temps, comme la coroutine elle-même n'utilise pas de threads, elle réduit la surcharge liée au changement de contexte de thread et constitue un modèle de développement efficace.

1. Écrire la fonction coroutine

Exemple : Utiliser la technologie coroutine pour développer la fonction d'accès aux pages Web

#用协程技术开发网页访问功能
from tornado import  gen #引入协程库gen
from tornado.httpclient import AsyncHTTPClient
import time

#使用gen.coroutine修饰器
@gen.coroutine
def coroutine_visit():
    http_client=AsyncHTTPClient()
    response=yield http_client.fetch("http://www.baidu.com")
    print(response.body)

Dans cet exemple, le client asynchrone AsyncHTTPClient est toujours utilisé pour la page traitement Pour l'accès, le décorateur @gen.coroutine déclare qu'il s'agit d'une fonction coroutine. En raison du mot-clé rendement, il n'est pas nécessaire d'écrire une fonction de rappel dans le code pour traiter les résultats de l'accès. Au lieu de cela, l'instruction de traitement des résultats peut être. écrit directement après la déclaration de rendement.

2. Appelez la fonction coroutine

Étant donné que la coroutine Tornado est implémentée sur la base du mot-clé rendement de Python, elle ne peut pas être appelée directement comme une fonction ordinaire.
Les fonctions coroutine peuvent être appelées des trois manières suivantes :

• Appelées via le mot-clé rendement au sein d'une fonction qui est elle-même une coroutine.

• Lorsque IOLoop n'a pas démarré, il est appelé via la fonction run_sync() d'IOLoop.

• Lorsque IOLoop a été démarré, il est appelé via la fonction spawn_callback() d'IOLoop.

Exemple : Appel de la fonction coroutine via la fonction coroutine

Code :

#用协程技术开发网页访问功能
from tornado import  gen #引入协程库gen
from tornado.httpclient import AsyncHTTPClient
import time

#使用gen.coroutine修饰器
@gen.coroutine
def coroutine_visit():
    http_client=AsyncHTTPClient()
    response=yield http_client.fetch("http://www.baidu.com")
    print(response.body)

@gen.coroutine
def outer_coroutine():
    print("start call coroutine_visit")
    yield coroutine_visit()
    print("end call coroutine_cisit")

Dans cet exemple, external_coroutine() et coroutine_visit() Il s'agit d'une fonction coroutine, elles peuvent donc être appelées via le mot-clé rendement. _

Exemple : Lorsque IOLoo n'a pas été démarré, il est appelé via la fonction run_sync() de IOLoop.

IOLoop est l'objet principal de boucle d'événements de Tornado. Le programme Tornado l'utilise pour surveiller les demandes d'accès des clients externes et effectuer les opérations correspondantes.

Code :

#用协程技术开发网页访问功能
from tornado import  gen #引入协程库gen
from tornado.httpclient import AsyncHTTPClient
from tornado.ioloop import IOLoop  #引入IOLoop对象

#使用gen.coroutine修饰器
@gen.coroutine
def coroutine_visit():
    http_client=AsyncHTTPClient()
    response=yield http_client.fetch("http://www.baidu.com")
    print(response.body)

def func_normal():
    print("start call coroutine_visit")
    IOLoop.current().run_sync(lambda :coroutine_visit())
    print("end call coroutine_visit")

Lorsque le programme n'est pas encore entré dans l'état d'exécution d'IOLoop, la fonction coroutine peut être appelée via la fonction run_sync().

Remarque : La fonction run_sync() bloquera l'appel de la fonction actuelle jusqu'à ce que la coroutine appelée soit exécutée.

En fait, Tornado nécessite que la fonction coroutine puisse être appelée dans l'état d'exécution d'IOLoop, mais la fonction run_sync termine automatiquement les étapes de démarrage et d'arrêt d'IOLoop. Sa logique d'implémentation est :

. [Démarrer IOLoop]》[Appelez la fonction coroutine encapsulée par lambda]》[Arrêtez IOLoop]

Exemple : Lorsque IOLoop est démarré, appelez

Code :

#用协程技术开发网页访问功能
from tornado import  gen #引入协程库gen
from tornado.httpclient import AsyncHTTPClient
from tornado.ioloop import IOLoop  #引入IOLoop对象

#使用gen.coroutine修饰器
@gen.coroutine
def coroutine_visit():
    http_client=AsyncHTTPClient()
    response=yield http_client.fetch("http://www.baidu.com")
    print(response.body)

def func_normal():
    print("start call coroutine_visit")
    IOLoop.current().spawn_callback(coroutine_visit)
    print("end call coroutine_visit")

La fonction spawn_callback() n'attendra pas que l'exécution de la coroutine appelée soit terminée. Toutes les instructions d'impression supérieure et inférieure seront terminées immédiatement, et la coroutine__visit elle-même sera exécutée par. IOLoop au moment opportun.

Remarque : la fonction spawn_callback() d'IOLoop ne fournit pas aux développeurs une méthode pour obtenir la valeur de retour d'un appel de fonction coroutine, donc span_callback() ne peut être utilisé que pour appeler des fonctions coroutine sans valeurs de retour.

3. Appeler des fonctions de blocage dans les coroutines

L'appel direct de fonctions de blocage dans les coroutines affectera les performances des coroutines elles-mêmes, donc Tornado fournit l'utilisation de pools de threads pour planifier les fonctions de blocage dans les coroutines, donc les méthodes qui le font n'affecte pas la poursuite de l'exécution de la coroutine elle-même.

Exemple de code :

from concurrent.futures import ThreadPoolExecutor
from tornado import gen

#定义线程池
thread_pool=ThreadPoolExecutor(2)

def mySleep(count):
    import time
    for x in range(count):
        time.sleep(1)

@gen.coroutine
def call_blocking():
    print("start")
    yield thread_pool.submit(mySleep,10)
    print("end")

Le code fait d'abord référence à la classe ThreadPoolExecutor de concurrent.futures et instancie un pool de threads thread_pool composé de deux threads. Dans la coroutine call_blocking qui doit appeler une fonction de blocage, utilisez thread_pool.submit pour appeler la fonction de blocage et la renvoyer via rendement. Cela ne bloquera pas l'exécution continue du thread où se trouve la coroutine, et garantira également l'ordre d'exécution du code avant et après la fonction de blocage.

4. Attente de plusieurs appels asynchrones dans la coroutine

Jusqu'à présent, nous connaissons la méthode de programmation consistant à attendre un appel asynchrone avec le mot-clé rendement dans la coroutine. En fait, Tornado vous permet d'utiliser un mot-clé Yield dans une coroutine pour attendre plusieurs appels asynchrones. Il vous suffit de transmettre ces appels au mot-clé Yield sous la forme d'une liste ou d'un dictionnaire.

Exemple : utilisez la méthode list pour passer plusieurs appels asynchrones

#使用列表方式传递多个异步调用
from tornado import gen  #引入协程库gen
from tornado.httpclient import AsyncHTTPClient

@gen.coroutine   #使用gen.coroutine修饰器
def coroutine_visit():
    http_client=AsyncHTTPClient()
    list_response=yield [
        http_client.fetch("http://www.baidu.com"),
        http_client.fetch("http://www.api.jiutouxiang.com")
    ]
    for response in list_response:
        print(response.body)

Utilisez toujours le décorateur @gen.coroutine pour définir des coroutines dans le code et utilisez des listes où le rendement est requis. plusieurs appels asynchrones, et rendement reviendra et poursuivra l'exécution seulement après que tous les appels de la liste auront été exécutés. rendement renvoie les résultats de l'appel dans une liste.

Exemple : Passer plusieurs appels asynchrones en mode dictionnaire :

#使用列表方式传递多个异步调用
from tornado import gen  #引入协程库gen
from tornado.httpclient import AsyncHTTPClient

@gen.coroutine   #使用gen.coroutine修饰器
def coroutine_visit():
    http_client=AsyncHTTPClient()
    dict_response=yield {
       "baidu": http_client.fetch("http://www.baidu.com"),
        "9siliao":http_client.fetch("http://www.api.jiutouxiang.com")
    }
    print(dict_response["baidu"].body)

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!