Python - 带有 asyncio/coroutine 的定时器

Question

我正在尝试设置一个计时器，它将中断正在运行的进程并在它触发时调用协程。但是，我不确定完成此操作的正确方法是什么。我找到了 AbstractEventLoop.call_later 和 threading.Timer，但它们似乎都不起作用（或者我使用不当）。代码非常基本，看起来像这样：

 def set_timer( time ):
    self.timer = Timer( 10.0, timeout )
    self.timer.start()
    #v2
    #self.timer = get_event_loop()
    #self.timer.call_later( 10.0, timeout )
    return

async def timeout():
    await some_func()
    return

设置非阻塞计时器的正确方法是什么，它会在几秒后调用回调函数？能够取消计时器将是一种奖励，但不是必需的。我需要的主要东西是：非阻塞和成功调用协程。现在它返回一个错误，对象不能被等待（如果我抛出一个等待）或者 some_func 从未被等待，并且预期的输出永远不会发生。

原文由 Greg Miller 发布，翻译遵循 CC BY-SA 4.0 许可协议

Answer 1

使用 ensure_future 创建 任务 是在不阻塞执行流程的情况下开始执行某些作业的常用方法。您也可以 取消 任务。

我为您编写了示例实现，让您可以从以下开始：

 import asyncio

class Timer:
    def __init__(self, timeout, callback):
        self._timeout = timeout
        self._callback = callback
        self._task = asyncio.ensure_future(self._job())

    async def _job(self):
        await asyncio.sleep(self._timeout)
        await self._callback()

    def cancel(self):
        self._task.cancel()

async def timeout_callback():
    await asyncio.sleep(0.1)
    print('echo!')

async def main():
    print('\nfirst example:')
    timer = Timer(2, timeout_callback)  # set timer for two seconds
    await asyncio.sleep(2.5)  # wait to see timer works

    print('\nsecond example:')
    timer = Timer(2, timeout_callback)  # set timer for two seconds
    await asyncio.sleep(1)
    timer.cancel()  # cancel it
    await asyncio.sleep(1.5)  # and wait to see it won't call callback

loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
try:
    loop.run_until_complete(main())
finally:
    loop.run_until_complete(loop.shutdown_asyncgens())
    loop.close()

输出：

 first example:
echo!

second example:

原文由 Mikhail Gerasimov 发布，翻译遵循 CC BY-SA 3.0 许可协议

Answer 2

感谢 Mikhail Gerasimov 的回答，它非常有用。这是 Mikhail 的答案的扩展。这是一个有一些曲折的间隔计时器。也许它对某些用户有用。

 import asyncio

class Timer:
    def __init__(self, interval, first_immediately, timer_name, context, callback):
        self._interval = interval
        self._first_immediately = first_immediately
        self._name = timer_name
        self._context = context
        self._callback = callback
        self._is_first_call = True
        self._ok = True
        self._task = asyncio.ensure_future(self._job())
        print(timer_name + " init done")

    async def _job(self):
        try:
            while self._ok:
                if not self._is_first_call or not self._first_immediately:
                    await asyncio.sleep(self._interval)
                await self._callback(self._name, self._context, self)
                self._is_first_call = False
        except Exception as ex:
            print(ex)

    def cancel(self):
        self._ok = False
        self._task.cancel()

async def some_callback(timer_name, context, timer):
    context['count'] += 1
    print('callback: ' + timer_name + ", count: " + str(context['count']))

    if timer_name == 'Timer 2' and context['count'] == 3:
        timer.cancel()
        print(timer_name + ": goodbye and thanks for all the fish")

timer1 = Timer(interval=1, first_immediately=True, timer_name="Timer 1", context={'count': 0}, callback=some_callback)
timer2 = Timer(interval=5, first_immediately=False, timer_name="Timer 2", context={'count': 0}, callback=some_callback)

try:
    loop = asyncio.get_event_loop()
    loop.run_forever()
except KeyboardInterrupt:
    timer1.cancel()
    timer2.cancel()
    print("clean up done")

原文由 Helgi Borg 发布，翻译遵循 CC BY-SA 4.0 许可协议