L'exécution d'une async tâche en arrière-plan dans la Tornade

La lecture de la Tornade de la documentation, il est très clair comment appeler une fonction async pour retourner une réponse:

class GenAsyncHandler(RequestHandler):
    @gen.coroutine
    def get(self):
        http_client = AsyncHTTPClient()
        response = yield http_client.fetch("http://example.com")
        do_something_with_response(response)
        self.render("template.html")

Ce qui manque, c'est comment un appel sera fait de manière asynchrone à une tâche de fond qui n'a pas de pertinence à la demande actuelle:

class GenAsyncHandler(RequestHandler):
    @gen.coroutine
    def _background_task():
        pass  # do lots of background stuff

    @gen.coroutine
    def get(self):
        _dont_care = yield self._background_task()
        self.render("template.html")

Ce code devrait fonctionner, sauf qu'il fonctionne de manière synchrone et la demande attend jusqu'à ce qu'il soit fini.

Quel est le droit façon asynchrone appel de cette tâche, tout juste de retour à la demande actuelle?

InformationsquelleAutor Yuval Adam | 2014-02-27

13

Mise à jour: Depuis Tornade 4.0 (juillet 2014), ci-dessous la fonctionnalité est disponible dans les IOLoop.spawn_callback méthode.

Malheureusement c'est le genre de difficile. Vous avez besoin à la fois de se détacher de la tâche en arrière-plan de la demande actuelle (de sorte qu'une défaillance dans la tâche d'arrière-plan n'entraîne pas une exception aléatoire jeté dans la demande) et de s'assurer que quelque chose est à l'écoute de la tâche en arrière-plan du résultat (pour se connecter à ses erreurs, si rien d'autre). Cela signifie quelque chose comme ceci:
```
from tornado.ioloop import IOLoop
from tornado.stack_context import run_in_stack_context, NullContext
IOLoop.current().add_future(run_in_stack_context(NullContext(), self._background_task),
                            lambda f: f.result())
```
Quelque chose comme ce sera probablement ajouté à la tornade lui-même dans l'avenir.
- L'espoir de voir cette ajoutés par la suite. Merci pour la parfaite réponse, et pour votre travail sur tornade 🙂
InformationsquelleAutor Ben Darnell

Je recommande d'utiliser toro. Il fournit un moyen relativement simple mécanisme pour la création d'un arrière-plan de la file d'attente des tâches.

Le code suivant (à mettre queue.py par exemple), commence un simple "travailleur()" qui attend tout simplement jusqu'à ce qu'il y a quelque chose dans sa file d'attente. Si vous appelez queue.add(function,async,*args,**kwargs) cela ajoute un élément à la file d'attente qui va réveiller travailleur() qui lance la tâche.

J'ai ajouté la async paramètre de sorte que cette mesure peut contribuer à des tâches de fond enveloppé dans @gen.coroutine et ceux sans.

import toro,tornado.gen
queue = toro.Queue()
@tornado.gen.coroutine
def add(function,async,*args,**kwargs):
   item = dict(function=function,async=async,args=args,kwargs=kwargs)
   yield queue.put(item)

@tornado.gen.coroutine
def worker():
   while True:
      print("worker() sleeping until I get next item")
      item = yield queue.get()
      print("worker() waking up to process: %s" % item)
      try:
         if item['async']:
            yield item['function'](*item['args'],**item['kwargs'])
         else:
            item['function'](*item['args'],**item['kwargs'])
      except Exception as e:
         print("worker() failed to run item: %s, received exception:\n%s" % (item,e))

@tornado.gen.coroutine
def start():
   yield worker()

Dans votre grande tornade application:

import queue
queue.start()

Et maintenant, vous pouvez planifier une tâche de fond tout simplement:

def my_func(arg1,somekwarg=None):
   print("in my_func() with %s %s" % (arg1,somekwarg))

queue.add(my_func,False,somearg,somekwarg=someval)

InformationsquelleAutor Mike N

J'ai une tâche fastidieuse dans la requête post, peut-être plus que 30 minutes, mais le client de retour à un résultat immédiat.

Tout d'abord, j'ai utilisé IOLoop.current().spawn_callback. Il fonctionne! mais! Si la première demande de la tâche est en cours d'exécution, deuxième demande de tâche bloquée! Parce que toutes les tâches sont dans l'événement principal de la boucle lors de l'utilisation spawn_callback, donc d'une tâche d'exécution synchrone, d'autres tâches bloquées.

Dernier, j'utilise la tornade.simultanées. Exemple:

import datetime
import time

from tornado.ioloop import IOLoop
import tornado.web
from tornado import concurrent

executor = concurrent.futures.ThreadPoolExecutor(8)


class Handler(tornado.web.RequestHandler):

    def get(self):
        def task(arg):
            for i in range(10):
                time.sleep(1)
                print(arg, i)

        executor.submit(task, datetime.datetime.now())
        self.write('request accepted')


def make_app():
    return tornado.web.Application([
        (r"/", Handler),
    ])


if __name__ == "__main__":
    app = make_app()
    app.listen(8000, '0.0.0.0')
    IOLoop.current().start()

et visite http://127.0.0.1:8000, vous pouvez voir qu'il est exécuté ok:

2017-01-17 22:42:10.983632 0
2017-01-17 22:42:10.983632 1
2017-01-17 22:42:10.983632 2
2017-01-17 22:42:13.710145 0
2017-01-17 22:42:10.983632 3
2017-01-17 22:42:13.710145 1
2017-01-17 22:42:10.983632 4
2017-01-17 22:42:13.710145 2
2017-01-17 22:42:10.983632 5
2017-01-17 22:42:16.694966 0
2017-01-17 22:42:13.710145 3
2017-01-17 22:42:10.983632 6
2017-01-17 22:42:16.694966 1
2017-01-17 22:42:13.710145 4
2017-01-17 22:42:10.983632 7
2017-01-17 22:42:16.694966 2
2017-01-17 22:42:13.710145 5
2017-01-17 22:42:10.983632 8
2017-01-17 22:42:16.694966 3
2017-01-17 22:42:13.710145 6
2017-01-17 22:42:19.790646 0
2017-01-17 22:42:10.983632 9
2017-01-17 22:42:16.694966 4
2017-01-17 22:42:13.710145 7
2017-01-17 22:42:19.790646 1
2017-01-17 22:42:16.694966 5
2017-01-17 22:42:13.710145 8
2017-01-17 22:42:19.790646 2
2017-01-17 22:42:16.694966 6
2017-01-17 22:42:13.710145 9
2017-01-17 22:42:19.790646 3
2017-01-17 22:42:16.694966 7
2017-01-17 22:42:19.790646 4
2017-01-17 22:42:16.694966 8
2017-01-17 22:42:19.790646 5
2017-01-17 22:42:16.694966 9
2017-01-17 22:42:19.790646 6
2017-01-17 22:42:19.790646 7
2017-01-17 22:42:19.790646 8
2017-01-17 22:42:19.790646 9

Veulent aider tout le monde!

InformationsquelleAutor Legolas Bloom

2

Il suffit de faire:
```
self._background_task()
```
La _background_task coroutine renvoie une Future qui est en suspens jusqu'à la coroutine est terminée. Si vous ne pas rendement de la Future, et au lieu simplement d'exécuter la ligne suivante immédiatement, puis get() ne pas attendre pour _background_task à la fin.

Un détail intéressant est que, jusqu'à ce que _background_task finitions, il conserve une référence à self. (N'oubliez pas d'ajouter self comme un paramètre, par la manière.) Votre RequestHandler ne sera pas nettoyée jusqu'à ce que après _background_task complète.
- Cela se révèle être légèrement plus difficile que je pensais, ma tâche est de faire certains non-trivial choses qui ne peuvent pas facilement être "asynchronized" posix (socket IO). Depuis sa bloque actuellement l'ensemble de l'OI de la boucle, il est difficile de test, mais cela semble être le bon sens, merci!
- Mais si vous n'avez pas le rendement / attendre le Future, le corps de la méthode fait exécuter?
InformationsquelleAutor A. Jesse Jiryu Davis

Vous devez vous connecter pour publier un commentaire.