gh-140746: Fix Thread.start() can hang forever

When a new thread is started (`Thread.start()`), the current thread
waits for the new thread's `_started` signal (`self._started.wait()`).
If the new thread doesn't have enough memory, it might crash before
signaling its start to the parent thread, causing the parent thread
to wait indefinitely (still in `Thread.start()`).

To fix this, we reintroduce the timeout for `Thread.start()` that was
removed by commit 9e7f1d2. When the
timeout occurs, we check `_os_thread_handle` to see if the thread has
somehow died. If it has, we can confirm the thread exited without
sending the start signal.

We also change `Thread._delete()` to use `pop` to remove the thread from
`_active`, as there is no guarantee that the thread exists in
`_active[get_ident()]`, thus avoiding a potential `KeyError`.
This can happen if `_bootstrap_inner` crashes before
`_active[self._ident] = self` executes. We use `self._ident` because we
know `set_ident()` has already been called.

Moreover, remove the old comment in `_delete` because
`_active_limbo_lock` became reentrant in commit
243fd01.

Author: ryv-odoo

Lib/test/test_threading.py

@@ -1457,6 +1457,32 @@ def run_in_bg():
         self.assertEqual(err, b"")
         self.assertEqual(out.strip(), b"Exiting...")
 
+    def test_memory_error_bootstrap(self):
+        # gh-140746: Test that Thread.start() doesn't hang indefinitely if
+        # the new thread fails (MemoryError) during its initialization
+
+        def serving_thread():
+
+            def nothing():
+                pass
+
+            def _set_ident_memory_error():
+                raise MemoryError()
+
+            thread = threading.Thread(target=nothing)
+            with (
+                support.catch_unraisable_exception(),
+                mock.patch.object(thread, '_set_ident', _set_ident_memory_error)
+            ):
+                thread.start()
+                self.assertFalse(thread in threading._limbo)
+                self.assertFalse(thread.is_alive())
+
+        serving_thread = threading.Thread(target=serving_thread)
+        serving_thread.start()
+        serving_thread.join(0.1)
+        self.assertFalse(serving_thread.is_alive())
+
 class ThreadJoinOnShutdown(BaseTestCase):
 
     def _run_and_join(self, script):

Lib/threading.py

@@ -1001,7 +1001,14 @@ def start(self):
             with _active_limbo_lock:
                 del _limbo[self]
             raise
-        self._started.wait()  # Will set ident and native_id
+        # It's possible that the _started event never occurs from the new Thread;
+        # e.g., it didn't have enough memory to call the initialization part of _bootstrap_inner.
+        while not self._started.wait(0.000001):
+            if self._os_thread_handle.is_done():
+                self._started.set()
+                with _active_limbo_lock:
+                    _limbo.pop(self, None)
+                break
 
     def run(self):
         """Method representing the thread's activity.
@@ -1081,11 +1088,7 @@ def _bootstrap_inner(self):
     def _delete(self):
         "Remove current thread from the dict of currently running threads."
         with _active_limbo_lock:
-            del _active[get_ident()]
-            # There must not be any python code between the previous line
-            # and after the lock is released.  Otherwise a tracing function
-            # could try to acquire the lock again in the same thread, (in
-            # current_thread()), and would block.
+            _active.pop(self._ident, None)
 
     def join(self, timeout=None):
         """Wait until the thread terminates.