Python tornado异步队列未等待

我在Tornado中修改了producer&consumer的示例队列，但传递给get（）的超时参数似乎根本不起作用，因为消费者在抛出异常之前不会等待10秒。理想情况下，生产者和消费者将同时运行。另外，我不知道是以秒还是毫秒的形式传入timeout参数：

from tornado import gen
from tornado.ioloop import IOLoop
from tornado.queues import Queue

q = Queue()

@gen.coroutine
def consumer():
    try:
        while True:
            item = yield q.get(timeout=10000)
            try:
                print('Doing work on %s' % item)      
            finally:
                q.task_done()
    except gen.TimeoutError:
        print('timeout')
        return

@gen.coroutine
def producer():
    for item in range(5):
        yield q.put(item)
        print('Put %s' % item)
        yield gen.sleep(2)

@gen.coroutine
def main():
    # Start consumer without waiting (since it never finishes).
    IOLoop.current().spawn_callback(consumer)
    yield producer()     # Wait for producer to put all tasks.
    yield q.join()       # Wait for consumer to finish all tasks.
    print('Done')

IOLoop.current().run_sync(main)

以下是它的执行：

Put 0
Doing work on 0
timeout
Put 1
Put 2
Put 3
Put 4

---

超时时间

正如您在中所读到的：

返回一个Future，该Future在项目可用或超时后引发tornado.gen.TimeoutError时解析

但这可能会产生误导，因为

超时

实际上是一个

截止日期

。因此，必须使用以下两种方式之一指定：

或绝对时间：

timeout = 1.5  # in seconds, floats acceptable
deadline = IOLoop.current().time() + timeout
# in most cases IOLoop time is just time.time()
# I've used separate variables only for the notion

yield q.get(timeout=deadline)

在中，它被合并到Tornado中，这个参数被称为

deadline

您在代码中指定了超时时间

10000

，这意味着截止时间为

周四，1970年1月1日02:46:40 GMT

消费者循环

由于您有

尝试

/

除

之外的整个功能块，包括循环时的

，当出现
超时错误时，您的消费者停止工作。将异常处理移动到
循环中

工作示例：

from tornado import gen
from tornado.ioloop import IOLoop
from tornado.queues import Queue

q = Queue()

@gen.coroutine
def consumer():
    i = 0
    while True:
        i += 1
        print('get cycle %s' % i)
        try:
            item = yield q.get(IOLoop.instance().time() + 3)
            try:
                print('Doing work on %s' % item)
            finally:
                q.task_done()
        except gen.TimeoutError:
            print('timeout')

@gen.coroutine
def producer():
    for item in range(5):
        yield q.put(item)
        print('Put %s' % item)
        yield gen.sleep(2)

@gen.coroutine
def main():
    # Start consumer without waiting (since it never finishes).
    IOLoop.current().spawn_callback(consumer)
    yield producer()     # Wait for producer to put all tasks.
    yield q.join()       # Wait for consumer to finish all tasks.
    print('Done')

超时时间

正如您在中所读到的：

返回一个Future，该Future在项目可用或超时后引发tornado.gen.TimeoutError时解析

但这可能会产生误导，因为
超时
实际上是一个
截止日期
。因此，必须使用以下两种方式之一指定：

或绝对时间：

timeout = 1.5  # in seconds, floats acceptable
deadline = IOLoop.current().time() + timeout
# in most cases IOLoop time is just time.time()
# I've used separate variables only for the notion

yield q.get(timeout=deadline)

在中，它被合并到Tornado中，这个参数被称为
deadline

您在代码中指定了超时时间
10000
，这意味着截止时间为
周四，1970年1月1日02:46:40 GMT

消费者循环

由于您有
尝试
/
除
之外的整个功能块，包括
循环时的
，当出现
超时错误时，您的消费者停止工作。将异常处理移动到
循环中

工作示例：

from tornado import gen
from tornado.ioloop import IOLoop
from tornado.queues import Queue

q = Queue()

@gen.coroutine
def consumer():
    i = 0
    while True:
        i += 1
        print('get cycle %s' % i)
        try:
            item = yield q.get(IOLoop.instance().time() + 3)
            try:
                print('Doing work on %s' % item)
            finally:
                q.task_done()
        except gen.TimeoutError:
            print('timeout')

@gen.coroutine
def producer():
    for item in range(5):
        yield q.put(item)
        print('Put %s' % item)
        yield gen.sleep(2)

@gen.coroutine
def main():
    # Start consumer without waiting (since it never finishes).
    IOLoop.current().spawn_callback(consumer)
    yield producer()     # Wait for producer to put all tasks.
    yield q.join()       # Wait for consumer to finish all tasks.
    print('Done')