Einfache asynchrone Beispiel mit tornado-python

Tornado ist konzipiert, um alle Ihre Operationen in einem einzigen thread, sondern nutzen den asynchronen I/O zu vermeiden, blockieren Sie so viel wie möglich. Wenn die DB Sie verwenden, über asychrone Python-Bindungen (im Idealfall ausgerichtet für Tornado speziell, wie Motor für MongoDB oder momoko für Postgres), dann werden Sie in der Lage zur Ausführung Ihrer DB-Abfragen, ohne zu blockieren den server; keine separate Prozesse oder threads gebraucht werden.

Zur Adresse, den genauen Beispiel, das Sie Gaben, wo time.sleep(1) aufgerufen wird, könnten Sie diesen Ansatz verwenden, um es zu tun asynchron via tornado Coroutinen:

#!/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()

Der interessante Teil ist async_sleep. Diese Methode ist die Schaffung eine asynchrone Task, die den Aufruf der ioloop.add_timeout Methode. add_timeout eine angegebene callback-nach einer bestimmten Anzahl von Sekunden, ohne die Blockierung der ioloop während der Wartezeit für den timeout abläuft. Es erwartet zwei Argumente:

add_timeout(deadline, callback) # deadline is the number of seconds to wait, callback is the method to call after deadline.

Wie Sie sehen können in dem obigen Beispiel haben wir uns nur für die Bereitstellung von einem parameter zum add_timeout explizit im code, was bedeutet, dass wir am Ende dieses:

add_timeout(time.time() + seconds, ???)

Wir sind nicht die Bereitstellung der erwarteten parameter callback. In der Tat, wenn gen.Task führt add_timeout es hängt ein callback keyword argument an das Ende der explizit mit Parametern versorgt. Also diese:

yield gen.Task(loop.add_timeout, time.time() + seconds)

Ergebnisse in dieser wird ausgeführt, innerhalb gen.Aufgabe():

loop.add_timeout(time.time() + seconds, callback=gen.Callback(some_unique_key))

Wenn gen.Callback ausgeführt wird, nachdem der timeout, es signalisiert, dass die gen.Task abgeschlossen ist, und die Programmausführung wird fortgesetzt auf der nächsten Zeile. Dieser Fluss ist schwierig zu verstehen, zumindest auf den ersten (es war sicherlich für mich, wenn ich zuerst Lesen es). Es wäre wohl hilfreich zu Lesen, über die Tornado-gen Modul-Dokumentation ein paar mal.

Hier aktualisiere ich die Informationen über Tornado 5.0. Tornado 5.0 eine neue Methode hinzufügen IOLoop.run_in_executor. In der "Aufrufen-blocking-Funktion" von Coroutine Muster Kapitel:

Den einfachsten Weg zum Aufruf einer blockierenden Funktion aus einer coroutine ist die Verwendung IOLoop.run_in_executor gibt Futures, die kompatibel sind mit Coroutinen:

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

Auch in der documeng von run_on_executor, sagt:

Dieser Dekorator sollte nicht verwechselt werden mit dem ähnlich benannten IOLoop.run_in_executor. Im Allgemeinen, mit run_in_executor beim Aufruf einer blockierenden Methode wird empfohlen, statt der Verwendung dieser Dekorator bei der Definition einer Methode. Wenn die Kompatibilität mit älteren Versionen von Tornado erforderlich ist, sollten die Definition eines Anbieters und mit dem Vollzieher.submit() auf den Aufruf von site.

In der 5.0-version, IOLoop.run_in_executor wird empfohlen, im use-case-blockierende Funktionen aufzurufen.