只要有待处理的取消屏蔽任务留下但不再存在，我如何运行 asyncio 循环？

我正在尝试向现有的 asyncio 循环添加一些代码，以提供 Ctrl-C 上的干净关闭。下面是它正在做的事情的抽象。

import asyncio, signal

async def task1():
    print("Starting simulated task1")
    await asyncio.sleep(5)
    print("Finished simulated task1")

async def task2():
    print("Starting simulated task2")
    await asyncio.sleep(5)
    print("Finished simulated task2")

async def tasks():
    await task1()
    await task2()

async def task_loop():
    try:
        while True:
            await asyncio.shield(tasks())
            await asyncio.sleep(60)
    except asyncio.CancelledError:
        print("Shutting down task loop")
        raise

async def aiomain():
    loop = asyncio.get_running_loop()
    task = asyncio.Task(task_loop())
    loop.add_signal_handler(signal.SIGINT, task.cancel)
    await task

def main():
    try:
        asyncio.run(aiomain())
    except asyncio.CancelledError:
        pass

#def main():
#    try:
#        loop = asyncio.get_event_loop()
#        loop.create_task(aiomain())
#        loop.run_forever()
#    except asyncio.CancelledError:
#        pass

if __name__ == '__main__':
    main()

在这个例子中，想象一下序列task1 and task2一旦开始就需要完成，否则某些工件将处于不一致的状态。 （因此asyncio.shield调用的包装器tasks.)

使用上面的代码，如果我在脚本启动后不久就中断它并且它只是打印出来Starting simulated task1然后循环停止task2永远不会开始。如果我尝试切换到的版本main然后注释掉，即使循环被正确取消并且至少在几分钟内没有进一步发生，也永远不会退出。它确实有一些进展，因为它至少完成了任何正在进行的序列task1 and task2.

头脑风暴中的一些可能的解决方案，尽管我仍然感觉一定有一些更简单的东西我错过了：

• 创建一个包装器asyncio.shield它增加一个由同步的变量asyncio.Condition对象，运行屏蔽函数，然后递减变量。然后，在aiomain in a CancelledError处理程序，在重新引发异常之前等待变量达到零。 （在实现中，我可能会将其所有部分组合到一个类中__aexit__实施等待零CancelledError logic.)
• 跳过使用asyncio完全取消机制，而是使用asyncio.Event或类似的允许中断点或可中断睡眠。尽管这看起来确实更具侵入性，要求我指定哪些点被认为是可中断的，而不是声明哪些序列需要避免取消。

这个问题问得好。我在制定答案时学到了一些东西，所以我希望您仍然关注这个帖子。

首先要研究的是，shield() 方法是如何工作的？在这一点上，文档至少可以说是令人困惑的。直到读了test_tasks.py中的标准库测试代码我才弄清楚。这是我的理解：

考虑这个代码片段：

async def coro_a():
    await asyncio.sheild(task_b())
    ...
task_a = asyncio.create_task(coro_a())
task_a.cancel()

当执行task_a.cancel()语句时，task_a确实被取消了。 wait 语句抛出 CancelledError立即地，无需等待task_b完成。但task_b继续运行。外部任务 (a) 停止，但内部任务 (b) 没有停止。

这是程序的修改版本，说明了这一点。主要的变化是在 CancelledError 异常处理程序中插入等待，以使程序的存活时间延长几秒钟。我在 Windows 上运行，这就是为什么我也稍微改变了你的信号处理程序，但这只是一个小问题。我还在打印语句中添加了时间戳。

import asyncio
import signal
import time

async def task1():
    print("Starting simulated task1", time.time())
    await asyncio.sleep(5)
    print("Finished simulated task1", time.time())

async def task2():
    print("Starting simulated task2", time.time())
    await asyncio.sleep(5)
    print("Finished simulated task2", time.time())

async def tasks():
    await task1()
    await task2()

async def task_loop():
    try:
        while True:
            await asyncio.shield(tasks())
            await asyncio.sleep(60)
    except asyncio.CancelledError:
        print("Shutting down task loop", time.time())
        raise

async def aiomain():
    task = asyncio.create_task(task_loop())
    KillNicely(task)
    try:
        await task
    except asyncio.CancelledError:
        print("Caught CancelledError", time.time())
        await asyncio.sleep(5.0)
        raise

class KillNicely:
    def __init__(self, cancel_me):
        self.cancel_me = cancel_me
        self.old_sigint = signal.signal(signal.SIGINT,
                                        self.trap_control_c)

    def trap_control_c(self, signum, stack):
        if signum != signal.SIGINT:
            self.old_sigint(signum, stack)
        else:
            print("Got Control-C", time.time())
            print(self.cancel_me.cancel())

def main():
    try:
        asyncio.run(aiomain())
    except asyncio.CancelledError:
        print("Program exit, cancelled", time.time())

# Output when ctrlC is struck during task1
# 
# Starting simulated task1 1590871747.8977509
# Got Control-C 1590871750.8385916
# True
# Shutting down task loop 1590871750.8425908
# Caught CancelledError 1590871750.8435903
# Finished simulated task1 1590871752.908434
# Starting simulated task2 1590871752.908434
# Program exit, cancelled 1590871755.8488846        

if __name__ == '__main__':
    main()

您可以看到您的程序无法运行，因为在task_loop 被取消后，在task1 和task2 有机会完成之前它就退出了。它们一直都在那里（或者更确切地说，如果程序继续运行，它们就会在那里）。

这说明了shield()和cancel()如何交互，但它实际上并没有解决您所说的问题。为此，我认为，您需要有一个可等待的对象，您可以使用它来使程序保持活动状态，直到重要任务完成。该对象需要在顶层创建，并将堆栈向下传递到执行重要任务的位置。这是一个与您的程序类似的程序，但按照您想要的方式执行。

我运行了 3 次：(1) 在任务 1 期间使用 control-C，(2) 在任务 2 期间使用 control-C，(3) 在两个任务完成后使用 control-C。在前两种情况下，程序会继续执行，直到任务 2 完成。在第三种情况下，它立即结束。

import asyncio
import signal
import time

async def task1():
    print("Starting simulated task1", time.time())
    await asyncio.sleep(5)
    print("Finished simulated task1", time.time())

async def task2():
    print("Starting simulated task2", time.time())
    await asyncio.sleep(5)
    print("Finished simulated task2", time.time())

async def tasks(kwrap):
    fut = asyncio.get_running_loop().create_future()
    kwrap.awaitable = fut
    await task1()
    await task2()
    fut.set_result(1)

async def task_loop(kwrap):
    try:
        while True:
            await asyncio.shield(tasks(kwrap))
            await asyncio.sleep(60)
    except asyncio.CancelledError:
        print("Shutting down task loop", time.time())
        raise

async def aiomain():
    kwrap = KillWrapper()
    task = asyncio.create_task(task_loop(kwrap))
    KillNicely(task)
    try:
        await task
    except asyncio.CancelledError:
        print("Caught CancelledError", time.time())
        await kwrap.awaitable
        raise

class KillNicely:
    def __init__(self, cancel_me):
        self.cancel_me = cancel_me
        self.old_sigint = signal.signal(signal.SIGINT,
                                        self.trap_control_c)

    def trap_control_c(self, signum, stack):
        if signum != signal.SIGINT:
            self.old_sigint(signum, stack)
        else:
            print("Got Control-C", time.time())
            print(self.cancel_me.cancel())

class KillWrapper:
    def __init__(self):
        self.awaitable = asyncio.get_running_loop().create_future()
        self.awaitable.set_result(0)

def main():
    try:
        asyncio.run(aiomain())
    except asyncio.CancelledError:
        print("Program exit, cancelled", time.time())

# Run 1 Control-C during task1
# Starting simulated task1 1590872408.6737766
# Got Control-C 1590872410.7344952
# True
# Shutting down task loop 1590872410.7354996
# Caught CancelledError 1590872410.7354996
# Finished simulated task1 1590872413.6747622
# Starting simulated task2 1590872413.6747622
# Finished simulated task2 1590872418.6750958
# Program exit, cancelled 1590872418.6750958
#
# Run 1 Control-C during task2
# Starting simulated task1 1590872492.927735
# Finished simulated task1 1590872497.9280624
# Starting simulated task2 1590872497.9280624
# Got Control-C 1590872499.5973852
# True
# Shutting down task loop 1590872499.5983844
# Caught CancelledError 1590872499.5983844
# Finished simulated task2 1590872502.9274273
# Program exit, cancelled 1590872502.9287038
#
# Run 1 Control-C after task2 -> immediate exit
# Starting simulated task1 1590873694.2925708
# Finished simulated task1 1590873699.2928336
# Starting simulated task2 1590873699.2928336
# Finished simulated task2 1590873704.2938952
# Got Control-C 1590873706.0790765
# True
# Shutting down task loop 1590873706.0804725
# Caught CancelledError 1590873706.0804725
# Program exit, cancelled 1590873706.0814824