add _discard_shutdown_lock() in threading module

python · shihai1991 · Apr 6, 2021 · Apr 8, 2021 · Apr 9, 2021 · Apr 8, 2021
commit 213cd7727ac8badd6efc4737baee10c463c530ae
diff --git a/Lib/test/test_threading.py b/Lib/test/test_threading.py
@@ -882,6 +882,20 @@ def noop(): pass
             threading.Thread(target=noop).start()
             # Thread.join() is not called
 
+    def test_leak_without_join_2(self):
+        # Same as above, but a delay gets introduced after the thread's
+        # Python code returned but before the thread state is deleted.
+        def random_sleep():
+            seconds = random.random() * 0.010
+            time.sleep(seconds)
+
+        def f():
+            random_sleep()
+
+        with threading_helper.wait_threads_exit():
+            threading.Thread(target=f).start()
+            # Thread.join() is not called
+
 
 class ThreadJoinOnShutdown(BaseTestCase):
 

diff --git a/Lib/threading.py b/Lib/threading.py
@@ -839,16 +839,6 @@ class is implemented.
         # For debugging and _after_fork()
         _dangling.add(self)
 
-    def __del__(self):
-        if not self._initialized:
-            return
-        lock = self._tstate_lock
-        if lock is not None and not self.daemon:
-            if lock.acquire(False):
-                lock.release()
-                with _shutdown_locks_lock:
-                    _shutdown_locks.discard(lock)
-
     def _reset_internal_locks(self, is_alive):
         # private!  Called by _after_fork() to reset our internal locks as
         # they may be in an invalid state leading to a deadlock or crash.
@@ -1417,6 +1407,13 @@ def _register_atexit(func, *arg, **kwargs):
 
 _main_thread = _MainThread()
 
+def _discard_shutdown_lock(lock):
+    """
+    Discard the Thread._tstate_lock lock when the non-daemon thread have done.
+    """
+    with _shutdown_locks_lock:
+        _shutdown_locks.discard(lock)
+
 def _shutdown():
     """
     Wait until the Python thread state of all non-daemon threads get deleted.

diff --git a/Modules/_threadmodule.c b/Modules/_threadmodule.c
@@ -3,8 +3,9 @@
 /* Interface to Sjoerd's portable C thread library */
 
 #include "Python.h"
-#include "pycore_pylifecycle.h"
 #include "pycore_interp.h"        // _PyInterpreterState.num_threads
+#include "pycore_pyerrors.h"      // _PyErr_Occurred()
+#include "pycore_pylifecycle.h"
 #include "pycore_pystate.h"       // _PyThreadState_Init()
 #include <stddef.h>               // offsetof()
 #include "structmember.h"         // PyMemberDef
@@ -20,6 +21,7 @@ _Py_IDENTIFIER(__dict__);
 
 _Py_IDENTIFIER(stderr);
 _Py_IDENTIFIER(flush);
+_Py_IDENTIFIER(threading);
 
 
 // Forward declarations
@@ -1277,19 +1279,40 @@ In most applications `threading.enumerate()` should be used instead.");
 static void
 release_sentinel(void *wr_raw)
 {
+    _Py_IDENTIFIER(_discard_shutdown_lock);
     PyObject *wr = _PyObject_CAST(wr_raw);
     /* Tricky: this function is called when the current thread state
        is being deleted.  Therefore, only simple C code can safely
        execute here. */
     PyObject *obj = PyWeakref_GET_OBJECT(wr);
     lockobject *lock;
+
     if (obj != Py_None) {
         lock = (lockobject *) obj;
         if (lock->locked) {
             PyThread_release_lock(lock->lock_lock);
             lock->locked = 0;
         }
+        PyThreadState *tstate = _PyThreadState_GET();
+        PyObject *threading = _PyImport_GetModuleId(&PyId_threading);
+        if (threading == NULL) {
+            if (!_PyErr_Occurred(tstate)) {
+                _PyErr_SetString(tstate, PyExc_RuntimeError,
+                                 "lost threading module");
+            }
+            goto exit;
+        }
+        PyObject *result = _PyObject_CallMethodIdOneArg(
+            threading, &PyId__discard_shutdown_lock, obj);
+        if (result == NULL) {
+            PyErr_WriteUnraisable(threading);
+        } else {
+            Py_DECREF(result);
+        }
+        Py_DECREF(threading);
     }
+
+exit:
     /* Deallocating a weakref with a NULL callback only calls
        PyObject_GC_Del(), which can't call any Python code. */
     Py_DECREF(wr);