2 
from tornado import web, gen
import tornado, time

class CoroutineFactorialHandler(web.RequestHandler):
    @web.asynchronous
    @gen.coroutine
    def get(self, n, *args, **kwargs):
        n = int(n)
        def callbacker(iterator, callback):
            try:
                value = next(iterator)
            except StopIteration:
                value = StopIteration
            callback(value)

        def factorial(n):
            x = 1
            for i in range(1, n+1):
                x *= i
                yield

            yield x

        iterator = factorial(n)
        t = time.time()
        self.set_header("Content-Type", "text/plain")
        while True:
            response = yield gen.Task(callbacker, iterator)
            #log.debug("response: %r" %response)
            if response is StopIteration:
                break
            elif response:
                self.write("took : %f sec" %(time.time() - t))
                self.write("\n")
                self.write("f(%d) = %d" %(n, response))

        self.finish()

application = tornado.web.Application([
    (r"^/coroutine/factorial/(?P<n>\d+)", CoroutineFactorialHandler),
    #http://localhost:8888/coroutine/factorial/<int:n>
])

if __name__ == "__main__":
    application.listen(8888)
    ioloop = tornado.ioloop.IOLoop.instance()
    ioloop.start()

上面拉出的 21 行是简单的阶乘计算器。它以生成器的方式循环 N 次。

问题是，当这段代码执行时，它会阻塞整个龙卷风。

我想要实现的是为龙卷风编写一些帮助程序，将生成器视为协程，因此可以以异步方式服务请求。（我已阅读Using a simple python generator as a co-routine in a Tornado async handler?）

为什么简单的增加和乘以 n 循环会阻止整个龙卷风？

编辑：我编辑了代码以包含整个应用程序，您可以运行和测试它。我在 python 2.7 上运行龙卷风 3.1.1

4

1 回答 1

8

您必须记住 Tornado 在一个线程中运行。代码被拆分为在主循环中顺序调用的任务。如果其中一项任务需要很长时间才能完成（因为time.sleep()像阶乘这样的阻塞函数或一些繁重的计算），它将因此阻塞整个循环。

那你能做什么……？一种解决方案是使用以下方法创建循环IOLoop.add_callback()：

from tornado import web, gen
import tornado, time

class CoroutineFactorialHandler(web.RequestHandler):
    def factorial(self, limit=1):
        count = 1
        fact = 1
        while count <= limit:
            yield fact
            count = count + 1
            fact = fact * count 

    def loop(self):
        try:
            self.fact = self.generator.next()
            tornado.ioloop.IOLoop.instance().add_callback(self.loop)
        except StopIteration:
            self.write("took : %f sec" %(time.time() - self.t))
            self.write("\n")
            self.write("f(%d) = %d" % (self.n, self.fact))
            self.finish()

    @web.asynchronous
    def get(self, n, *args, **kwargs):
        self.n = int(n)
        self.generator = self.factorial(self.n)
        self.t = time.time()
        self.set_header("Content-Type", "text/plain")
        tornado.ioloop.IOLoop.instance().add_callback(self.loop)

application = tornado.web.Application([
    (r"^/coroutine/factorial/(?P<n>\d+)", CoroutineFactorialHandler),
    #http://localhost:8888/coroutine/factorial/<int:n>
])

if __name__ == "__main__":
    application.listen(8888)
    ioloop = tornado.ioloop.IOLoop.instance()
    ioloop.start()

这里的每个乘法都是一个单独的任务，它允许混合factorial来自不同请求的生成器调用。如果每次调用生成器都花费相同的时间，这是一个好方法。但是，如果您要计算 100000！然后在某个时间点，按顺序排列的任务看起来像 90000!*90001、90001!*90002 等等。即使它只有一个乘法而不是整个循环，也需要一些时间来计算它，因此另一个请求将被延迟。对于如此大的输入整数，您必须在另一个线程中进行计算才能公平地分享请求的处理器时间。以下是如何执行此操作的示例：http: //lbolla.info/blog/2013/01/22/blocking-tornado

附带说明一下，在阶乘中，您有很多冗余，因此您应该在内存中保留一些 n 的解决方案列表，以便立即将它们转回，而不会一遍又一遍地浪费处理器时间进行相同的计算。

于 2013-09-21T18:34:25.020 回答