Question

在龙卷风（或asyncio）中是否有行为/模式等待任何而不是list中的所有期货？

yield any_of([future1, future2, future3])

说future2已准备就绪，结果应为：

[None, <result>, None]

Answer 1

更新：Tornado现在有tornado.gen.WaitIterator，根据其文档中的示例使用它，而不是我的想法。

你可以制作一个继承Future的Any类，并包装一个期货列表。 Any类等待其中一个期货结算，然后给出结果列表：

import time
from tornado import gen
from tornado.ioloop import IOLoop
from tornado.concurrent import Future


@gen.coroutine
def delayed_msg(seconds, msg):
    yield gen.Task(IOLoop.current().add_timeout,
                   time.time() + seconds)
    raise gen.Return(msg)


class Any(Future):
    def __init__(self, futures):
        super(Any, self).__init__()
        self.futures = futures
        for future in futures:
            future.add_done_callback(self.done_callback)

    def done_callback(self, future):
        try:
            self.set_result(self.make_result())
        except Exception as e:
            self.set_exception(e)

    def make_result(self):
        """A list of results: None for each pending future, a result for
        each resolved future. Raises an exception for the first future
        that has an exception.
        """
        return [f.result() if f.done() else None
                for f in self.futures]

    def clear(self):
        """Break reference cycle with any pending futures."""
        self.futures = None


@gen.coroutine
def f():
    start = time.time()
    future1 = delayed_msg(2, '2')
    future2 = delayed_msg(3, '3')
    future3 = delayed_msg(1, '1')
    results = yield Any([future1, future2, future3])
    end = time.time()
    print "finished in %.1f sec: %r" % (end - start, results)

    results = yield Any([future1, future2])
    end = time.time()
    print "finished in %.1f sec: %r" % (end - start, results)

IOLoop.current().run_sync(f)

正如所料，这会打印出来：

finished in 1.0 sec: [None, None, '1']
finished in 2.0 sec: ['2', None]

但是你可以看到这种方法存在一些并发症。首先，如果你想在第一个期货结算后等待期货的 rest ，那么构建仍在等待的期货清单就很复杂了。我想你可以做到：

results = yield Any(f for f in [future1, future2, future3] if not f.done())

不漂亮，甚至不正确！有竞争条件。如果在连续执行yield Any(...)之间解决了未来，那么您将永远不会收到其结果。第一个yield没有得到未来的结果，因为它仍处于待定状态，但第二个yield也没有得到它的结果，因为在那一点上未来是“完成”并且它不是' t包含在传递给Any的列表中。

另一个复杂因素是Any指的是每个future，它指的是一个回调Any的回调。对于快速垃圾收集，您应该调用Any.clear（）。

此外，您无法区分待决的未来和已解决为无的未来。您需要一个与None无关的特殊标记值来表示未来的未来。

最后的并发症是最糟糕的。如果多个期货得到解决并且其中一些有例外，那么Any没有明显的方式将所有这些信息传达给您。在列表中混合异常和结果将是不正常的。

我认为有一种更简单的方法。我们可以让Any返回结果的第一个未来，而不是结果列表：

class Any(Future): def __init__(self, futures): super(Any, self).__init__() for future in futures: future.add_done_callback(self.done_callback) def done_callback(self, future): self.set_result(future)

参考周期消失了，并且回答了异常处理问题：Any类将整个未来返回给您，而不是结果或异常。你可以随意检查它。在一些问题得到解决之后，等待剩余的期货也很容易：

@gen.coroutine def f(): start = time.time() future1 = delayed_msg(2, '2') future2 = delayed_msg(3, '3') future3 = delayed_msg(1, '1') futures = set([future1, future2, future3]) while futures: resolved = yield Any(futures) end = time.time() print "finished in %.1f sec: %r" % (end - start, resolved.result()) futures.remove(resolved)

根据需要，打印：

finished in 1.0 sec: '1' finished in 2.0 sec: '2' finished in 3.0 sec: '3'

我们可以通过添加新的全局函数来测试异常处理行为：

@gen.coroutine def delayed_exc(seconds, msg): yield gen.Task(IOLoop.current().add_timeout, time.time() + seconds) raise Exception(msg)

而不是使用delayed_msg：

@gen.coroutine def f(): start = time.time() future1 = delayed_msg(2, '2') future2 = delayed_exc(3, '3') # Exception! future3 = delayed_msg(1, '1') futures = set([future1, future2, future3]) while futures: resolved = yield Any(futures) end = time.time() try: outcome = resolved.result() except Exception as e: outcome = e print "finished in %.1f sec: %r" % (end - start, outcome) futures.remove(resolved)

现在，脚本将打印“1”，然后是“2”，然后是“Exception（'3'，）”。

龙卷风发电机恢复任何未来的清单

1 个答案: