Add thread timeout constant

Author: aeros

Doc/library/asyncio-eventloop.rst

@@ -178,18 +178,27 @@ Running and stopping the loop
 
    .. versionadded:: 3.6
 
-.. coroutinemethod:: loop.shutdown_default_executor()
+.. coroutinemethod:: loop.shutdown_default_executor(timeout=None)
 
    Schedule the closure of the default executor and wait for it to join all of
    the threads in the :class:`ThreadPoolExecutor`. After calling this method, a
    :exc:`RuntimeError` will be raised if :meth:`loop.run_in_executor` is called
    while using the default executor.
 
+   The *timeout* parameter specifies the amount of time the threadpool will
+   be given to finish joining. The default value is ``None``, which means the
+   threadpool will be given an indefinite amount of time.
+
+   If the timeout duration is reached, a warning is emitted and threadpool is
+   terminated without waiting for its threads to finish joining.
+
    Note that there is no need to call this function when
    :func:`asyncio.run` is used.
 
    .. versionadded:: 3.9
 
+   .. versionchanged:: 3.12
+      Added the *timeout* parameter.
 
 Scheduling callbacks
 ^^^^^^^^^^^^^^^^^^^^

Doc/library/asyncio-runner.rst

@@ -41,6 +41,10 @@ Running an asyncio Program
    the end.  It should be used as a main entry point for asyncio
    programs, and should ideally only be called once.
 
+   The threadpool is given a timeout duration of 5 minutes to join its threads.
+   If the threadpool hasn't finishing joining within that duration, a warning is
+   emitted and the threadpool is closed.
+
    Example::
 
        async def main():

Lib/asyncio/base_events.py

@@ -561,8 +561,13 @@ async def shutdown_asyncgens(self):
                     'asyncgen': agen
                 })
 
-    async def shutdown_default_executor(self):
-        """Schedule the shutdown of the default executor."""
+    async def shutdown_default_executor(self, timeout=None):
+        """Schedule the shutdown of the default executor.
+
+        The timeout parameter specifies the amount of time the threadpool will
+        be given to finish joining. The default value is None, which means
+        that the threadpool will be given an indefinite amount of time.
+        """
         self._executor_shutdown_called = True
         if self._default_executor is None:
             return
@@ -572,7 +577,13 @@ async def shutdown_default_executor(self):
         try:
             await future
         finally:
-            thread.join()
+            thread.join(timeout)
+
+        if thread.is_alive():
+            warnings.warn("The ThreadPoolExecutor did not finishing joining "
+                             f"its threads within {timeout} seconds.",
+                             RuntimeWarning, stacklevel=2)
+            self._default_executor.shutdown(wait=False)
 
     def _do_shutdown(self, future):
         try:

Lib/asyncio/constants.py

@@ -26,6 +26,9 @@
 FLOW_CONTROL_HIGH_WATER_SSL_READ = 256  # KiB
 FLOW_CONTROL_HIGH_WATER_SSL_WRITE = 512  # KiB
 
+# Default timeout for joining the threads in the threadpool
+THREAD_JOIN_TIMEOUT = 300
+
 # The enum should be here to break circular dependencies between
 # base_events and sslproto
 class _SendfileMode(enum.Enum):

Lib/asyncio/runners.py

@@ -9,7 +9,7 @@
 from . import events
 from . import exceptions
 from . import tasks
-
+from . import constants
 
 class _State(enum.Enum):
     CREATED = "created"
@@ -69,7 +69,8 @@ def close(self):
             loop = self._loop
             _cancel_all_tasks(loop)
             loop.run_until_complete(loop.shutdown_asyncgens())
-            loop.run_until_complete(loop.shutdown_default_executor())
+            loop.run_until_complete(
+                loop.shutdown_default_executor(constants.THREAD_JOIN_TIMEOUT))
         finally:
             if self._set_event_loop:
                 events.set_event_loop(None)
@@ -160,8 +161,8 @@ def run(main, *, debug=None):
     """Execute the coroutine and return the result.
 
     This function runs the passed coroutine, taking care of
-    managing the asyncio event loop and finalizing asynchronous
-    generators.
+    managing the asyncio event loop, finalizing asynchronous
+    generators and closing the threadpool.
 
     This function cannot be called when another asyncio event loop is
     running in the same thread.
@@ -172,6 +173,9 @@ def run(main, *, debug=None):
     It should be used as a main entry point for asyncio programs, and should
     ideally only be called once.
 
+    The threadpool is given a timeout duration of 5 minutes. If its threads
+    haven't finishing joining within that duration, the threadpool is terminated.
+
     Example:
 
         async def main():

Misc/NEWS.d/next/Library/2019-09-25-00-37-51.bpo-38267.X9Jb5V.rst

@@ -0,0 +1 @@
+Add *timeout* parameter to :meth:`asyncio.loop.shutdown_default_executor`.