Question

在我的async处理程序中，我想等到任务的状态发生变化。现在，我只是在无限循环中检查状态并等待。这是一个例子，wait_until_done函数：

import asyncio


class LongTask:
    state = 'PENDING'

my_task = LongTask()


def done():
    my_task.state = 'DONE'

async def wait_until_done():
    while True:
        if my_task.state == 'PENDING':
            await asyncio.sleep(2)
        else:
            break
    print("Finally, the task is done")


def main(loop, *args, **kwargs):
    asyncio.ensure_future(wait_until_done())
    loop.call_later(delay=5, callback=done)

loop = asyncio.get_event_loop()
main(loop)
loop.run_forever()

有没有更好的方法呢？

Answer 1

为了避免混淆：我猜你不是在谈论asyncio.Task，而是一些变量状态，对吧？

在这种情况下，您拥有Future和synchronization primitives，可以让您等待某些异步更改的内容。

如果您需要在两种状态之间切换，asyncio.Event可能就是您想要的。这是一个小问题：

import asyncio


my_task = asyncio.Event()


def done():
    my_task.set()



async def wait_until_done():
    await my_task.wait()  # await until event would be .set()
    print("Finally, the task is done")


async def main():
    loop.call_later(delay=5, callback=done)
    await wait_until_done()


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

<强> UPD：

保持LongTask界面的更复杂的示例：

import asyncio



class LongTask:
    _event = asyncio.Event()

    @property
    def state(self):
        return 'PENDING' if not type(self)._event.is_set() else 'DONE'

    @state.setter
    def state(self, val):
        if val == 'PENDING':
            type(self)._event.clear()
        elif val == 'DONE':
            type(self)._event.set()
        else:
            raise ValueError('Bad state value.')

    async def is_done(self):
        return (await type(self)._event.wait())

my_task = LongTask()


def done():
    my_task.state = 'DONE'



async def wait_until_done():
    await my_task.is_done()
    print("Finally, the task is done")


async def main():
    loop.call_later(delay=5, callback=done)
    await wait_until_done()


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

Answer 2

这不是Observer设计模式的一个例子吗？我认为Observer模式可以解决这个问题。在这种设计模式中，我们不需要迭代无限来检测更改，而是任务本身将通知它是否已提交任何更改。一个简单的实现可能是：

class ObservableTask:
    def __init__(self):
        self.subscribers = set()
        self.state = 'PENDING'

    def subscribe(self, who):
        self.subscribers.add(who)

    def unsubscribe(self, who):
        self.subscribers.discard(who)

    def dispatch(self, message):
        for subscriber in self.subscribers:
            subscriber.update(message)

    def random_change(self):
        for count in range(1, 10):
            if count % 5 == 0:
                print('Inside task:\tDivisible by 5')
                self.state = 'DONE'
                self.dispatch('state: DONE')


class Observer:
    def __init__(self):
        pass

    def update(self, message):
        print('Task is changed!\t' + message)


# Test:
task = ObservableTask()
observer = Observer()

task.subscribe(observer)
task.random_change()

输出：

Inside task:    Divisible by 5
Task is changed!    state: DONE

如何等待对象改变状态

2 个答案: