Only check for non-daemon threads at finalization.

Since threading._shutdown() only shuts down non-daemon threads, daemon
threads would cause the loop to run indefinitely.

Author: ZeroIntensity

Include/cpython/pystate.h

@@ -107,6 +107,7 @@ struct _ts {
 #  define _PyThreadState_WHENCE_THREADING 3
 #  define _PyThreadState_WHENCE_GILSTATE 4
 #  define _PyThreadState_WHENCE_EXEC 5
+#  define _PyThreadState_WHENCE_THREADING_DAEMON 6
 #endif
 
     /* Currently holds the GIL. Must be its own field to avoid data races */

Modules/_threadmodule.c

@@ -415,7 +415,7 @@ force_done(void *arg)
 
 static int
 ThreadHandle_start(ThreadHandle *self, PyObject *func, PyObject *args,
-                   PyObject *kwargs)
+                   PyObject *kwargs, int daemon)
 {
     // Mark the handle as starting to prevent any other threads from doing so
     PyMutex_Lock(&self->mutex);
@@ -439,7 +439,8 @@ ThreadHandle_start(ThreadHandle *self, PyObject *func, PyObject *args,
         goto start_failed;
     }
     PyInterpreterState *interp = _PyInterpreterState_GET();
-    boot->tstate = _PyThreadState_New(interp, _PyThreadState_WHENCE_THREADING);
+    uint8_t whence = daemon ? _PyThreadState_WHENCE_THREADING_DAEMON : _PyThreadState_WHENCE_THREADING;
+    boot->tstate = _PyThreadState_New(interp, whence);
     if (boot->tstate == NULL) {
         PyMem_RawFree(boot);
         if (!PyErr_Occurred()) {
@@ -1874,7 +1875,7 @@ do_start_new_thread(thread_module_state *state, PyObject *func, PyObject *args,
         add_to_shutdown_handles(state, handle);
     }
 
-    if (ThreadHandle_start(handle, func, args, kwargs) < 0) {
+    if (ThreadHandle_start(handle, func, args, kwargs, daemon) < 0) {
         if (!daemon) {
             remove_from_shutdown_handles(handle);
         }

Python/pylifecycle.c

@@ -2006,15 +2006,32 @@ resolve_final_tstate(_PyRuntimeState *runtime)
 static int
 interp_has_threads(PyInterpreterState *interp)
 {
+    /* This needs to check for non-daemon threads only, otherwise we get stuck
+     * in an infinite loop. */
     assert(interp != NULL);
+    assert(interp->runtime->stoptheworld.world_stopped);
     assert(interp->threads.head != NULL);
-    return interp->threads.head->next != NULL;
+    if (interp->threads.head->next == NULL) {
+        // No other threads active, easy way out.
+        return 0;
+    }
+
+    // We don't have to worry about locking this because the
+    // world is stopped.
+    _Py_FOR_EACH_TSTATE_UNLOCKED(interp, tstate) {
+        if (tstate->_whence == _PyThreadState_WHENCE_THREADING) {
+            return 1;
+        }
+    }
+
+    return 0;
 }
 
 static int
 interp_has_pending_calls(PyInterpreterState *interp)
 {
     assert(interp != NULL);
+    assert(interp->runtime->stoptheworld.world_stopped);
     return interp->ceval.pending.npending != 0;
 }
 
@@ -2023,6 +2040,7 @@ interp_has_atexit_callbacks(PyInterpreterState *interp)
 {
     assert(interp != NULL);
     assert(interp->atexit.callbacks != NULL);
+    assert(interp->runtime->stoptheworld.world_stopped);
     assert(PyList_CheckExact(interp->atexit.callbacks));
     return PyList_GET_SIZE(interp->atexit.callbacks) != 0;
 }

Python/pystate.c

@@ -1447,7 +1447,7 @@ init_threadstate(_PyThreadStateImpl *_tstate,
     assert(tstate->prev == NULL);
 
     assert(tstate->_whence == _PyThreadState_WHENCE_NOTSET);
-    assert(whence >= 0 && whence <= _PyThreadState_WHENCE_EXEC);
+    assert(whence >= 0 && whence <= _PyThreadState_WHENCE_THREADING_DAEMON);
     tstate->_whence = whence;
 
     assert(id > 0);