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

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 not be able to
signal that it started to the parent thread, and the parent thread will
wait indefinitely.

To fix this, we reintroduce the old timeout for `Thread.start()`
that was used before commit 9e7f1d2.
When the timeout occurs, we check the `_os_thread_handle` to see if
the thread has somehow died. If it has, we can ensure the thread has
been killed without it having sent the start signal.

We also change `Thread._delete()` to use `pop` instead, because
nothing guarantees that the thread exists in
`_active[get_ident()]` (to avoid KeyError). `_bootstrap_inner` might
crash before `_active[self._ident] = self` executes. We also use
`self._ident` because we know that `set_ident` has already been
executed. Remove the old comment of `_delete` because
`_active_limbo_lock` has became reentrant since
243fd01

Author: Rémy Voet (ryv)

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.