缓存和重用函数会导致 Tornado

我有一个昂贵的功能要包含在我的 Tornado 应用程序中。功能 返回多个输出，但由于遗留原因，这些输出被访问 分别通过不同的处理程序。

有没有办法只执行一次函数，然后将结果重复使用 不同的处理程序并保留 Tornado 的异步行为？

from tornado.web import RequestHandler
from tonado.ioloop import IOLoop

# the expensive function
def add(x, y):
    z = x + y
    return x, y, z

# the handlers that reuse the function
class Get_X(RequestHandler):
    def get(self, x, y):
        x, y, z = add(x, y) 
        return x

class Get_Y(RequestHandler):
    def get(self, x, y):
        x, y, z = add(x, y) 
        return y

class Get_Z(RequestHandler):
    def get(self, x, y):
        x, y, z = add(x, y) 
        return z

# the web service
application = tornado.web.Application([
    (r'/Get_X', Get_X),
    (r'/Get_Y', Get_Y),
    (r'/Get_Z', Get_Z),
])

application.listen(8888)
IOLoop.current().start()

我考虑过将函数的结果缓存在字典中，但我不确定如何让其他两个处理程序等待，而第一个处理程序创建一个字典条目。

Tornado Futures是可重复使用的，所以你可以简单地保存Future在屈服之前。许多现成的缓存装饰器（例如 python 3.2 的functools.lru_cache如果你把它们放在前面就会起作用@gen.coroutine:

import functools
from tornado import gen
from tornado.ioloop import IOLoop

@functools.lru_cache(maxsize=100)
@gen.coroutine
def expensive_function():
    print('starting expensive_function')
    yield gen.sleep(5)
    return 1, 2, 3

@gen.coroutine
def get_x():
    print('starting get_x')
    x, y, z = yield expensive_function()
    return x

@gen.coroutine
def get_y():
    print('starting get_y')
    x, y, z = yield expensive_function()
    return y

@gen.coroutine
def get_z():
    print('starting get_z')
    x, y, z = yield expensive_function()
    return z

@gen.coroutine
def main():
    x, y, z = yield [get_x(), get_y(), get_z()]
    print(x, y, z)

if __name__ == '__main__':
    IOLoop.current().run_sync(main)

Prints:

starting get_x
starting expensive_function
starting get_y
starting get_z
finished expensive_function
1 2 3