Atomically check if there are threads, atexit callbacks, or pending calls.

Author: ZeroIntensity

Modules/_threadmodule.c

@@ -347,6 +347,7 @@ thread_run(void *boot_raw)
 {
     struct bootstate *boot = (struct bootstate *) boot_raw;
     PyThreadState *tstate = boot->tstate;
+    PyInterpreterState *interp = tstate->interp;
 
     // Wait until the handle is marked as running
     PyEvent_Wait(&boot->handle_ready);
@@ -373,7 +374,7 @@ thread_run(void *boot_raw)
 
     _PyThreadState_Bind(tstate);
     PyEval_AcquireThread(tstate);
-    _Py_atomic_add_ssize(&tstate->interp->threads.count, 1);
+    _Py_atomic_add_ssize(&interp->threads.count, 1);
 
     PyObject *res = PyObject_Call(boot->func, boot->args, boot->kwargs);
     if (res == NULL) {
@@ -391,13 +392,13 @@ thread_run(void *boot_raw)
 
     thread_bootstate_free(boot, 1);
 
-    _Py_atomic_add_ssize(&tstate->interp->threads.count, -1);
+    _Py_atomic_add_ssize(&interp->threads.count, -1);
     PyThreadState_Clear(tstate);
     _PyThreadState_DeleteCurrent(tstate);
 
 exit:
     // Don't need to wait for this thread anymore
-    remove_from_shutdown_handles(handle, _PyInterpreterState_GET());
+    remove_from_shutdown_handles(handle, interp);
 
     _PyEvent_Notify(&handle->thread_is_exiting);
     ThreadHandle_decref(handle);
@@ -1881,7 +1882,7 @@ do_start_new_thread(thread_module_state *state, PyObject *func, PyObject *args,
 
     if (ThreadHandle_start(handle, func, args, kwargs) < 0) {
         if (!daemon) {
-            remove_from_shutdown_handles(handle, _PyInterpreterState_GET());
+            remove_from_shutdown_handles(handle, interp);
         }
         return -1;
     }

Python/pylifecycle.c

@@ -2003,9 +2003,35 @@ resolve_final_tstate(_PyRuntimeState *runtime)
     return main_tstate;
 }
 
+static int
+interp_has_threads(PyInterpreterState *interp)
+{
+    assert(interp != NULL);
+    assert(interp->threads.head != NULL);
+    return interp->threads.head->next != NULL;
+}
+
+static int
+interp_has_pending_calls(PyInterpreterState *interp)
+{
+    assert(interp != NULL);
+    return interp->ceval.pending.npending != 0;
+}
+
+static int
+interp_has_atexit_callbacks(PyInterpreterState *interp)
+{
+    assert(interp != NULL);
+    assert(interp->atexit.callbacks != NULL);
+    assert(PyList_CheckExact(interp->atexit.callbacks));
+    return PyList_GET_SIZE(interp->atexit.callbacks) != 0;
+}
+
 static void
 make_pre_finalization_calls(PyThreadState *tstate)
 {
+    assert(tstate != NULL);
+    PyInterpreterState *interp = tstate->interp;
     /* Each of these functions can start one another, e.g. a pending call
      * could start a thread or vice versa. To ensure that we properly clean
      * call everything, we run these in a loop until none of them run anything. */
@@ -2028,7 +2054,14 @@ make_pre_finalization_calls(PyThreadState *tstate)
 
         _PyAtExit_Call(tstate->interp);
 
+        _PyRWMutex_Lock(&tstate->interp->prefini_mutex);
+        int should_continue = (interp_has_threads(interp)
+                              || interp_has_atexit_callbacks(interp)
+                              || interp_has_pending_calls(interp));
         _PyRWMutex_Unlock(&tstate->interp->prefini_mutex);
+        if (!should_continue) {
+            break;
+        }
     }
 }