Asyncio python：如何在协程中调用对象方法？

Question

我目前正在尝试做这样的事情：

import asyncio

class Dummy:
    def method(self):
        return 1
    def __str__(self):
        return "THIS IS A DUMMY CLASS"

async def start_doing():
    asyncio.sleep(1)
    return Dummy


async def do_something():
    return start_doing().method()


async def main():
    a = asyncio.create_task(do_something())
    b = asyncio.create_task(do_something())

    results = await asyncio.gather(a, b)
    print(results)

asyncio.run(main())

但我收到此错误：

AttributeError: 'coroutine' object has no attribute 'method'

这表明我不能在协程对象上调用我的方法。解决此问题的一种方法是执行以下操作：

async def do_something():
    return (await start_doing()).method()

但我认为通过这样做，您本质上就是使您的代码同步。您不是在生成未来，而是在 do_something 中等待您的工作完成，然后继续执行队列中的下一项。

当 awaitable 已被等待并且我的对象已准备好时，我应该如何调用对象方法？如何安排它在未来被调用？

Answer 1

等待调用，然后在返回的类的实例上调用方法。

async def start_doing():
    await asyncio.sleep(1)
    return Dummy


async def do_something():
    thing = await start_doing()
    return thing().method()

---

当 awaitable 已被等待并且我的对象已准备好时，我应该如何在将来调用对象方法？如何安排它在未来被调用？

看看我能不能把这个弄对。

• 当您创建任务 do_something 时，它会被安排。
• 最终，事件循环决定让do_something 启动。
• do_something 调用 start_doing 并等待它。
• 当do_something 等待时，事件循环会从它手中夺走控制权，让其他东西轮流。
• 在某些时间点start_doing 被调度、启动、完成等待/休眠、返回对象
  • 在等待/睡眠部分控制可能已被事件循环转移到其他任务
• 最终在do_something 完成等待后，事件循环将控制/焦点交还给它。
  • 暗示其他计划任务已完成或正在等待某事。

我真的不知道调度算法是什么，我认为它是一个循环的事情，但它可能比这更智能。

Answer 2

要进一步扩展@wwii 的answer 并解决使用await 的阻塞风险问题，您可以使用以下f 之类的功能：

import time
from datetime import datetime
import asyncio

start = datetime.now()

async def f(x, block_for=3):
    print(f"{x} IN     {ellapsed_time()}s")
    time.sleep(block_for)
    print(f"{x} AWAIT  {ellapsed_time()}s")
    await asyncio.sleep(x)
    print(f"{x} OUT    {ellapsed_time()}s")
    
def ellapsed_time():
    return (datetime.now() - start).seconds
    

asyncio.create_task(f(2))
asyncio.create_task(f(1))

产生：

2 IN     0s
2 AWAIT  3s
1 IN     3s
1 AWAIT  6s
2 OUT    6s
1 OUT    7s

在调用await 之前，f(2) 处于阻塞状态（阻止任何其他任务被调度）。一旦我们调用await，我们就明确地通知调度程序我们正在等待某些东西（通常是I/O，但这里是simply "sleeping"）。同样，f(1) 阻止 f(2) 出去，直到它调用 await。

如果我们删除阻塞部分（0s 的阻塞）f(1) 将被重新安排在f(2) 之前执行，因此将首先完成：

>>> start = datetime.now()
>>> asyncio.create_task(f(2, block_for=0))
>>> asyncio.create_task(f(1, block_for=0))

2 IN     0s
2 AWAIT  0s
1 IN     0s
1 AWAIT  0s
1 OUT    1s
2 OUT    2s

最后，关于这部分：

…如何安排它在未来被调用？

你可以看看how is asyncio.sleep() in python implemented?，它可能会帮助你更好地理解异步编程的工作原理。