Question

我有一个正在尝试使其同步的龙卷风服务器。我有一个客户端，它同时向服务器发出异步请求。它每5秒钟使用一次心跳ping服务器一次，其次，它会在可能的情况下发出GET请求。

在服务器端，有一个包含作业的线程安全队列。如果队列为空，它将阻塞20秒。我希望它保持该连接并阻塞20秒钟，当它返回时，它会向客户端写入“无作业”。作业可用后，应立即将其写入客户端，因为queue.get（）将返回。我希望在此请求被阻止的同时，心跳继续在后台发生。在这里，我正在从同一个客户端向服务器发出两个异步请求。

这是我构建的一个示例项目，可以模拟我的问题。

服务器：

import tornado.ioloop
import tornado.web
from queue import Queue
from tornado import gen

q = Queue()


class HeartBeatHandler(tornado.web.RequestHandler):
    @gen.coroutine
    def post(self):
        print("Heart beat")


class JobHandler(tornado.web.RequestHandler):
    @gen.coroutine
    def get(self):
        print("Job")
        try:
            job = yield q.get(block=True, timeout=20)
            self.write(job)
        except Exception as e:
            self.write("No job")


def make_app():
    return tornado.web.Application([
        (r"/heartbeat", HeartBeatHandler),
        (r"/job", JobHandler),
    ])


if __name__ == "__main__":
    app = make_app()
    app.listen(8888)
    try:
        tornado.ioloop.IOLoop.current().start()
    except KeyboardInterrupt:
        tornado.ioloop.IOLoop.current().stop()

客户：

import asyncio
from tornado import httpclient, gen


@gen.coroutine
def heartbeat_routine():
    while True:
        http_client = httpclient.AsyncHTTPClient()
        heartbeat_request = httpclient.HTTPRequest("http://{}/heartbeat".format("127.0.0.1:8888"), method="POST",
                                                   body="")
        try:
            yield http_client.fetch(heartbeat_request)
            yield asyncio.sleep(5)
        except httpclient.HTTPError as e:
            print("Heartbeat failed!\nError: {}".format(str(e)))

        http_client.close()


@gen.coroutine
def worker_routine():
    while True:
        http_client = httpclient.AsyncHTTPClient(defaults=dict(request_timeout=180))
        job_request = httpclient.HTTPRequest("http://{}/job".format("127.0.0.1:8888"), method="GET")
        try:
            response = yield http_client.fetch(job_request)
            print(response.body)
        except httpclient.HTTPError as e:
            print("Heartbeat failed!\nError: {}".format(str(e)))

        http_client.close()


if __name__ == "__main__":
    loop = asyncio.get_event_loop()
    asyncio.ensure_future(heartbeat_routine())
    asyncio.ensure_future(worker_routine())
    loop.run_forever()

问题：

问题在于心跳也会在那20秒内阻塞而queue.get（）阻止。我不要。
您可以在我的客户端中看到，我将请求超时设置为180秒。但是那似乎从未与龙卷风一起使用。如果将queue.get（）超时增加到20以上秒，它返回错误代码，表明请求已超时。

Answer 1

如果使用线程安全队列，则必须不使用IOLoop线程的阻塞操作。而是在线程池中运行它们：
```
job = yield IOLoop.current().run_in_executor(None, lambda: q.get(block=True, timeout=20))
```
或者，您可以使用Tornado的异步（但线程不安全）队列，并在需要与另一个线程的队列进行交互时使用IOLoop.add_callback。
AsyncHTTPClient构造函数中有一些不可思议之处，它试图在可能的情况下共享现有实例，但这意味着构造函数参数仅在第一次生效。 worker_routine正在选择heartbeat_routine创建的默认实例。添加force_instance=True，以确保您在worker_routine中获得新的客户（并在完成后调用.close()）

与Tornado服务器的多个异步HTTP连接

1 个答案: