Question

我的代码：

import tornado.tcpserver
import tornado.ioloop
import itertools
import socket
import time

class Talk():
    def __init__(self, id):
        self.id = id

    @tornado.gen.coroutine
    def on_connect(self):
        try:
            while "connection alive":
                self.said = yield self.stream.read_until(b"\n") 

                response = yield tornado.gen.Task(self.task)     ### LINE 1

                yield self.stream.write(response)                   ### LINE 2

        except tornado.iostream.StreamClosedError:
            print('error: socket closed')
        return

    @tornado.gen.coroutine
    def task(self):
        if self.id == 1:
           time.sleep(3)  # sometimes request is heavy blocking
        return b"response"

    @tornado.gen.coroutine
    def on_disconnect(self):
        yield []


class Server(tornado.tcpserver.TCPServer):

    def __init__(self, io_loop=None, ssl_options=None, max_buffer_size=None):

        tornado.tcpserver.TCPServer.__init__(self,
            io_loop=io_loop,
            ssl_options=ssl_options,
            max_buffer_size=max_buffer_size)

        self.talk_id_alloc = itertools.count(1)
        return


    @tornado.gen.coroutine
    def handle_stream(self, stream, address):
        talk_id = next(self.talk_id_alloc)
        talk = Talk(talk_id)

        stream.set_close_callback(talk.on_disconnect)
        stream.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
        stream.socket.setsockopt(socket.IPPROTO_TCP, socket.SO_KEEPALIVE, 1)

        talk.stream = stream

        yield talk.on_connect()

        return

Server().listen(8888)
tornado.ioloop.IOLoop.instance().start()

问题：

我需要龙卷风作为tcp服务器 - 它似乎是处理许多低计算请求的好选择。

但是：

  99% of requests will last less than 0,05 sec, but
  1% of them can last even 3 sec (special cases).
  single response must be returned at once, not partially.

这里最好的方法是什么？如何实现一个代码，其中LINE＃1永远不会阻塞超过0.1秒

 yield tornado.gen.with_timeout(
    datetime.timedelta(seconds=0.1), tornado.gen.Task(self.task))

不能为我工作 - 什么都不做

 tornado.ioloop.IOLoop.current().add_timeout(
      datetime.timedelta(seconds=0.1),
      lambda: result.set_exception(TimeoutError("Timeout")))

要么一无所获。

寻找更好的解决方案：

任务可以检测是否需要高计算（API ...） - 使用超时？，然后运行/ fork到另一个线程甚至进程并发送到龙卷风服务器execption - 稍后从结果队列“接收”我（消费者/生产者）我不想要超时杀死繁重任务而不保存结果的情况，并且在特殊包装器中重新打开任务 - 所以消费者/生产者模式应该适用于所有任务？
当电流被阻止时添加新的ioloop - 如何检测阻塞？

我在龙卷风中没有看到任何解决方案。

第1行中的

任务可能很简单（~99％）或复杂，这可能需要：

 I/O:
 - disk/DB access
 - ram/redis access
 network:
 - API call
 CPU:
 - algorithms, regex

（最糟糕的任务将完成上述所有工作）。只有当我开始做它时，我知道它是什么类型的任务（重量），所以appriopriate是在不同的线程中使用任务队列。我不想要延迟简单/快速的任务。

Answer 1

因此，如果您设法取消繁重的任务，我建议您在超时的情况下取消它们，然后将它们产生到另一个线程。性能方面，这不是理想的（GIL），但是你可以阻止龙卷风阻挡 - 这是你的最终目标。

关于如何做到这一点的一篇很好的文章可以在这里找到：http://lbolla.info/blog/2013/01/22/blocking-tornado。

如果你想更进一步，你可以使用像芹菜这样的东西，你可以透明地卸载到其他过程 - 虽然这个更重。

龙卷风中繁重任务的并发性

1 个答案: