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

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

Answer 1

使用Task创建ensure_future是在不阻止执行流程的情况下开始执行某个作业的常用方法。您还可以cancel个任务。

我为您编写了示例实现，以便从中开始：

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:

Answer 2

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

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")

Answer 3

Mikhail 提出的解决方案有一个缺点。调用 cancel() 会同时取消：计时器和实际回调（如果 cancel() 在超时后触发，但实际作业仍在进行中）。取消作业本身可能不是您想要的行为。

另一种方法是使用 loop.call_later：

async def some_job():
    print('Job started')
    await asyncio.sleep(5)
    print('Job is done')

loop = asyncio.get_event_loop() # or asyncio.get_running_loop()

timeout = 5
timer = loop.call_later(timeout, lambda: asyncio.ensure_future(some_job()))

timer.cancel() # cancels the timer, but not the job, if it's already started

Python - 带有asyncio / coroutine的计时器

3 个答案: