如何创建一个永远在其上运行滚动协程的事件循环？

Question

为了防止上下文切换，我想创建一个大循环来服务网络连接和一些例程。

下面是普通函数的实现：

import asyncio
import time


def hello_world(loop):
    print('Hello World')
    loop.call_later(1, hello_world, loop)

def good_evening(loop):
    print('Good Evening')
    loop.call_later(1, good_evening, loop)

print('step: asyncio.get_event_loop()')
loop = asyncio.get_event_loop()

print('step: loop.call_soon(hello_world, loop)')
loop.call_soon(hello_world, loop)
print('step: loop.call_soon(good_evening, loop)')
loop.call_soon(good_evening, loop)

try:
    # Blocking call interrupted by loop.stop()
    print('step: loop.run_forever()')
    loop.run_forever()
except KeyboardInterrupt:
    pass
finally:
    print('step: loop.close()')
    loop.close()

这是协程的实现：

import asyncio


@asyncio.coroutine
def hello_world():
    while True:
        yield from asyncio.sleep(1)
        print('Hello World')

@asyncio.coroutine
def good_evening():
    while True:
        yield from asyncio.sleep(1)
        print('Good Evening')

print('step: asyncio.get_event_loop()')
loop = asyncio.get_event_loop()
try:
    print('step: loop.run_until_complete()')
    loop.run_until_complete(asyncio.wait([
        hello_world(),
        good_evening()
    ]))
except KeyboardInterrupt:
    pass
finally:
    print('step: loop.close()')
    loop.close()

还有混合的：

import asyncio
import time


def hello_world(loop):
    print('Hello World')
    loop.call_later(1, hello_world, loop)

def good_evening(loop):
    print('Good Evening')
    loop.call_later(1, good_evening, loop)

@asyncio.coroutine
def hello_world_coroutine():
    while True:
        yield from asyncio.sleep(1)
        print('Hello World Coroutine')

@asyncio.coroutine
def good_evening_coroutine():
    while True:
        yield from asyncio.sleep(1)
        print('Good Evening Coroutine')

print('step: asyncio.get_event_loop()')
loop = asyncio.get_event_loop()

print('step: loop.call_soon(hello_world, loop)')
loop.call_soon(hello_world, loop)
print('step: loop.call_soon(good_evening, loop)')
loop.call_soon(good_evening, loop)
print('step: asyncio.async(hello_world_coroutine)')
asyncio.async(hello_world_coroutine())
print('step: asyncio.async(good_evening_coroutine)')
asyncio.async(good_evening_coroutine())

try:
    loop.run_forever()
except KeyboardInterrupt:
    pass
finally:
    print('step: loop.close()')
    loop.close()

如您所见，每个协程函数都有一个 while 循环。我怎样才能让它像正常的一样？ IE。完成后，在给定的延迟时间后调用自身，但不只是在那里放一个循环。

Answer 1

您是否真的尝试运行您提供的三个示例？行为上的差异非常明显。

由于您从未说出您的期望，因此无法分辨什么是正确的，什么不是。这三种实现可能是对的，也可能是错的。我可以告诉你每个实现有什么行为，以及为什么它有这样的行为；只有你知道它是否正确。

---

在第二个示例（yield from asyncio.sleep(1)）中，两个协程同时运行。这意味着每个人都将自己执行； hello_world 每秒打印一次Hello World，good_evening 每秒打印一次Good Evening。

另外两个例子都使用time.sleep(1)，这是阻塞的。这意味着当第一个函数（无论是哪个；假设它是 hello_world）到达 time.sleep(1) 时，整个程序将挂起一秒钟。这意味着当hello_world 休眠时，good_evening 也无法运行，反之亦然。

程序执行如下：

1. 循环进入。
2. 循环调用hello_world。
3. 到达hello_world 中的time.sleep(1)。程序休眠一秒钟。
4. Hello World 已打印。
5. hello_world 收益。
6. 循环调用good_evening。
7. Good Evening 已打印。
8. 到达good_evening 中的time.sleep(1)。程序休眠一秒钟。
9. good_evening 收益。
10. 转到 2。

因此Hello World 和Good Evening 都每两 秒出现一次，因为在每个print 之间有两个time.sleep(1) 调用。如果您运行这两个示例，您会很容易注意到这一点。

Answer 2

import asyncio


@asyncio.coroutine
def hello_world_coroutine():
    yield from asyncio.sleep(1)
    print('Hello World Coroutine')
    yield from hello_world_coroutine()

@asyncio.coroutine
def good_evening_coroutine():
    yield from asyncio.sleep(1)
    print('Good Evening Coroutine')
    yield from good_evening_coroutine()

print('step: asyncio.get_event_loop()')
loop = asyncio.get_event_loop()
try:
    print('step: loop.run_until_complete()')
    loop.run_until_complete(asyncio.wait([
        hello_world_coroutine(),
        good_evening_coroutine()
    ]))
except KeyboardInterrupt:
    pass
finally:
    print('step: loop.close()')
    loop.close()

UPD

此代码将达到最大递归深度。可能是因为 Python 没有尾调用优化。将此处的代码作为错误示例。

Answer 3

如果你真的想从协程中消除 while 循环（我不知道你为什么觉得这是必要的；这是做你想做的最自然的方式），你可以使用 asyncio.async （或asyncio.ensure_future 在 Python 3.4.4+ 上）安排协程在下一次事件循环迭代中再次运行：

import asyncio

@asyncio.coroutine
def hello_world():
    yield from asyncio.sleep(1)
    print('Hello World')
    asyncio.async(hello_world())

@asyncio.coroutine
def good_evening():
    yield from asyncio.sleep(1)
    print('Good Evening')
    asyncio.async(good_evening())

print('step: asyncio.get_event_loop()')
loop = asyncio.get_event_loop()
try:
    print('step: loop.run_until_complete()')
    asyncio.async(hello_world())
    asyncio.async(good_evening())
    loop.run_forever()
except KeyboardInterrupt:
    pass
finally:
    print('step: loop.close()')
    loop.close()

请注意，如果这样做，您必须切换回使用loop.run_forever()，因为hello_world/good_evening 将在打印后立即退出。

Answer 4

# asyncio_coroutine_forever.py

import asyncio

async def hello_world():

    await asyncio.sleep(1)
    print('Hello World')
    await good_evening()


async def good_evening():

    await asyncio.sleep(1)
    print('Good Evening')
    await hello_world()


loop = asyncio.get_event_loop()

try:

    loop.run_until_complete(hello_world())
    loop.run_until_complete(good_evening())
    loop.run_forever()

finally:

    print('closing event loop')
    loop.close()