Python 在dict中管理异步协同路由

我想在运行主协程的同时，在dict中管理一些协程。 具体地说，我想开始无休止的协同程序，将它们的处理程序放在dict中，然后再次通过dict调用取消它们。在我的示例中，我想启动4个协同程序，它们将随着协同程序

世界末日

再次逐个取消。我正在使用Python 3.6

import asyncio
import traceback


async def add_to_handler(node, func):
    func_handler[node] = asyncio.ensure_future(func, loop=loop)
    return

async def test_func1():
    while True:
        print("1 - HeNlO")
        await asyncio.sleep(1)

async def test_func2():
    while True:
        print("2 - TestFunc2")
        await asyncio.sleep(2)


async def test_func3():
    while True:
        print("3 - Tukan")
        await asyncio.sleep(3)


async def test_func4():
    while True:
        print("4 - Do Coro!")
        await asyncio.sleep(4)


async def doomsday():
    # Cancel coroutine every 10 seconds
    print("launch doomsday")
    for i in range(len(func_handler)):
        await asyncio.sleep(10)
        print("start cancelling with {}".format(i))
        func_handler[str(i + 1)].cancel()
    return

async def main():
    await add_to_handler("1", test_func1)
    await add_to_handler("2", test_func2)
    await add_to_handler("3", test_func3)
    await add_to_handler("4", test_func4)
    await doomsday()
    while True:
        print("z..z..Z..Z...Z")
        print(func_handler)
        await asyncio.sleep(5)

func_handler = {}

loop = asyncio.get_event_loop()
try:
    loop.run_until_complete(main())
except KeyboardInterrupt:
    print("stop loop")
    loop.close()

---

我尝试了AbstractEventLoop的

.call\u later

方法，而不是一个无休止的while循环，但它仍然不想工作，而且似乎我的协同程序被视为函数，但我不知道为什么。我的错在哪里？

尝试更改此功能：

async def add_to_处理程序（节点，func）：
func\u handler[node]=asyncio.sure\u future（func（），loop=loop）
一无所获

---

注意异步。确保将来（func（），loop=loop）

尝试更改此函数：

async def add_to_处理程序（节点，func）：
func\u handler[node]=asyncio.sure\u future（func（），loop=loop）
一无所获

---

注意异步IO。确保未来（func（），loop=loop）

有时候会遗漏一些小东西，谢谢。我试图将while-True循环放在一个与

asyncio的协同程序中的main中。确保将来（main\u sleep（），loop=loop）

（要清楚，它没有列在dict中）。但是在取消dict中的最后一个协程后，循环会自动退出（以一种明确的方式），但是我的主睡眠（）协程不应该仍然挂起/运行吗？如果

loop，例程主睡眠（）将自动终止。运行直到完成（main（））

将完成执行并作为

asyncio。确保未来（主睡眠（），循环=loop）

是在异步循环中执行的，它不会阻止主函数完成其执行，您可以按照现在的方式执行，也可以将其称为

wait main_sleep（）

有时会遗漏一些小东西，谢谢。我试图将while-True循环放在一个与

asyncio的协同程序中的main中。确保将来（main\u sleep（），loop=loop）

（要清楚，它没有列在dict中）。但是在取消dict中的最后一个协程后，循环会自动退出（以一种明确的方式），但是我的主睡眠（）协程不应该仍然挂起/运行吗？如果

loop，例程主睡眠（）将自动终止。运行直到完成（main（））

将完成执行并作为

asyncio。确保未来（主睡眠（），循环=loop）

是在异步循环中执行的，它不会阻止主函数完成其执行，您可以按照现在的方式执行，也可以将其称为

wait main\u sleep（）