use a canary task to detect asyncio.run shutdown - and join selector thread there

[graingert]

I was looking at trying to shutdown the selector thread when using asyncio.run, and I think it's possible by starting a task that sleeps until it is cancelled, and then loses the reference to it.

This way there's only two ways it can terminate, by asyncio.run using _cancel_all_tasks and loop.close() removing the sleep timer handle:

async def _canary_task(selector_thread_wr):
    try:
        while True:  # uvloop clams sleeps to 1000 years, and someone could fast-forward the uv clock
             await asyncio.sleep(math.inf)
    except asyncio.CancelledError:
        # asyncio.run is calling _cancel_all_tasks - join selector thread here
        selector_thread = selector_thread_wr()
        if selector_thread is not None:
             # notify selector thread and join it
            
    except GeneratorExit:
        # loop.close() was called without _cancel_all_tasks notify selector thread to shutdown but don't join it

[bdarnell]

I have to admit that it took me a while to see what the issue is - asyncio.run closes its loop, and we join the thread in AddThreadSelectorEventLoop.close, so what's the problem? Of course the wrapper AddThreadSelectorEventLoop isn't the same object as the one used by asyncio.run, d'oh!

This seems like a reasonable approach; it's probably the best we can do without global changes (i.e. changing the policy so that asyncio.run constructs an AddThreadSelectorEventLoop).

[bdarnell]

Coming back to this after a while, and one thing's not clear: why does CancelledError notify and join, while GeneratorExit notifies without joining? Shouldn't we be able to join after notification either way?

[bdarnell]

Having spent some time on this, I'm seeing that it's difficult to clean up the thread cleanly without also producing warnings about un-awaited tasks or tasks destroyed while they are pending.

In the GC/GeneratorExit case, it seems very difficult to escape the warnings logged when a pending task is GC'd. The problem is that I haven't figured out how to have a task in a position to catch a GeneratorExit without logging a warning even when things are shut down cleanly.

The asyncio.run/CancelledError case is more frustrating. It seems like we should be able to catch the CancelledError cleanly to shut down when asyncio.run is used, with no side effects if it is not. But I haven't been able to come up with a solution that works.

#3272 currently passes its tests, meaning it cleans up its threads. But it logs spurious warnings, and there's no good way to silence them. It's better to log a warning than to leak a thread, and windows isn't a fully-supported platform, but it's still ugly to have that warning all the time.

Maybe this is a good reason to clean up the SelectorThread code and submit it upstream to cpython for 3.13. There the cleanup would be unambiguous.

[bdarnell]

#3272 is now merged, which detects the closure of the event loop with an async generator and cleans up the thread. This means that we clean things up reliably when asyncio.run, asyncio.Runner, or event_loop.shutdown_asyncgens are used, although we still have a thread leak if none of those are used (as in the original pre-3.6 versions of asyncio)