Simple async exemple avec tornade python

Je veux trouver simple async exemple de serveur.
J'ai une fonction avec beaucoup d'attente, les transactions de base de données ... etc:

def blocking_task(n):
    for i in xrange(n):
        print i
        sleep(1)
    return i

J'ai besoin d'exécuter la fonction dans des processus séparés sans blocage. Est-il possible?

OriginalL'auteur user1941407 | 2014-04-07

16

Tornade est conçu pour exécuter toutes vos opérations dans un seul thread, mais utiliser les e/S asynchrones, pour éviter de bloquer autant que possible. Si la DB que vous utilisez dispose asychronous bindings Python (idéalement à ceux conçus pour les Tornado plus précisément, comme Moteur pour MongoDB ou momoko pour Postgres), alors vous serez en mesure d'exécuter vos requêtes DB sans bloquer le serveur; pas de processus ou threads nécessaire.

À l'adresse exacte de l'exemple que vous avez donné, où time.sleep(1) est appelé, vous pouvez utiliser cette approche pour le faire de manière asynchrone via tornade coroutines:
```
#!/usr/bin/python

import tornado.web
from tornado.ioloop import IOLoop
from tornado import gen 
import time

@gen.coroutine
def async_sleep(seconds):
    yield gen.Task(IOLoop.instance().add_timeout, time.time() + seconds)

class TestHandler(tornado.web.RequestHandler):
    @gen.coroutine
    def get(self):
        for i in xrange(100):
            print i
            yield async_sleep(1)
        self.write(str(i))
        self.finish()


application = tornado.web.Application([
    (r"/test", TestHandler),
    ])  

application.listen(9999)
IOLoop.instance().start()
```
La partie intéressante est async_sleep. Cette méthode est la création d'une Tâche asynchrone, qui est l'appel de la ioloop.add_timeout méthode. add_timeout va lancer un rappel spécifié après un nombre donné de secondes, sans blocage de la ioloop lors de l'attente pour le délai d'expiration. Il attend deux arguments:
```
add_timeout(deadline, callback) # deadline is the number of seconds to wait, callback is the method to call after deadline.
```
Comme vous pouvez le voir dans l'exemple ci-dessus, nous ne sommes qu'à réellement fournir un paramètre add_timeout explicitement dans le code, ce qui signifie que nous fin de cette présente:
```
add_timeout(time.time() + seconds, ???)
```
Nous ne sommes pas fournir les attendus de rappel paramètre. En fait, quand gen.Task exécute add_timeout, il ajoute une callback argument mot-clé à la fin de l'fournies explicitement les paramètres. Donc:
```
yield gen.Task(loop.add_timeout, time.time() + seconds)
```
Résultats de cet être exécuté à l'intérieur d'gen.Tâche():
```
loop.add_timeout(time.time() + seconds, callback=gen.Callback(some_unique_key))
```
Quand gen.Callback est exécuté après le délai d'attente, il signale que le gen.Task est terminée, et l'exécution du programme va continuer sur la ligne suivante. Ce flux est le genre de difficile à comprendre, au moins dans un premier temps (c'était certainement le cas pour moi quand j'ai lu à ce sujet). Il sera probablement utile de lire sur les Tornade gen documentation du module à quelques reprises.

pourquoi ne pas utiliser asynchrone attendent pour gen_async fonction?
Cette réponse a été écrit avant async/await a été ajouté à Python.

OriginalL'auteur dano

import tornado.web
from tornado.ioloop import IOLoop
from tornado import gen

from tornado.concurrent import run_on_executor
from concurrent.futures import ThreadPoolExecutor   # `pip install futures` for python2

MAX_WORKERS = 16

class TestHandler(tornado.web.RequestHandler):
    executor = ThreadPoolExecutor(max_workers=MAX_WORKERS)

    """
    In below function goes your time consuming task
    """

    @run_on_executor
    def background_task(self):
        sm = 0
        for i in range(10 ** 8):
            sm = sm + 1

        return sm

    @tornado.gen.coroutine
    def get(self):
        """ Request that asynchronously calls background task. """
        res = yield self.background_task()
        self.write(str(res))

class TestHandler2(tornado.web.RequestHandler):
    @gen.coroutine
    def get(self):
        self.write('Response from server')
        self.finish()


application = tornado.web.Application([
    (r"/A", TestHandler),
    (r"/B", TestHandler2),
    ])

application.listen(5000)
IOLoop.instance().start()

Lorsque vous exécutez le code ci-dessus, vous pouvez exécuter un calcul coûteux à http://127.0.0.1:5000/A , qui ne bloque pas l'exécution, voir en visitant http://127.0.0.1:5000/B immédiatement après que vous visitez http://127.0.0.1:5000/A.

OriginalL'auteur Iaroslav

2

Ici-je mettre à jour les informations sur la Tornade 5.0. Tornade 5.0 ajouter une nouvelle méthode IOLoop.run_in_executor. Dans "l'Appel de fonctions de blocage" de Coroutine modèles Chapitre:

La façon la plus simple d'appeler une fonction de blocage à partir d'une coroutine est d'utiliser IOLoop.run_in_executor, qui renvoie à Terme qui sont compatibles avec les coroutines:

@gen.coroutine def call_blocking(): yield IOLoop.current().run_in_executor(blocking_func, args)

Aussi, dans le documeng de run_on_executor, est dit:

Ce décorateur ne doit pas être confondu avec le même nom de IOLoop.run_in_executor. En général, l'utilisation de run_in_executor lors de l'appel d'un blocage de la méthode est recommandée à la place de l'utilisation de ce décorateur lors de la définition d'une méthode. Si la compatibilité avec les anciennes versions de Tornade est nécessaire, envisager de définir un exécuteur testamentaire ou à l'aide de l'exécuteur testamentaire.submit() sur le site d'appel.

En version 5.0, IOLoop.run_in_executor est recommandé en cas d'utilisation d'Appeler les fonctions de blocage.

OriginalL'auteur Qianyue

Vous devez vous connecter pour publier un commentaire.