- rename bootstrapped => running

- merge wait method + is_failed: wait return False if the boostrapping has failed.

Author: Rémy Voet (ryv)

Lib/threading.py

@@ -953,7 +953,7 @@ def _after_fork(self, new_ident=None):
     def __repr__(self):
         assert self._initialized, "Thread.__init__() was not called"
         status = "initial"
-        if self._os_thread_handle.is_bootstrapped():
+        if self._os_thread_handle.is_running():
             status = "started"
         if self._os_thread_handle.is_done():
             status = "stopped"
@@ -976,7 +976,7 @@ def start(self):
         if not self._initialized:
             raise RuntimeError("thread.__init__() not called")
 
-        if self._os_thread_handle.is_bootstrapped():
+        if self._os_thread_handle.is_running():
             raise RuntimeError("threads can only be started once")
 
         with _active_limbo_lock:
@@ -999,11 +999,10 @@ def start(self):
             with _active_limbo_lock:
                 del _limbo[self]
             raise
-        self._os_thread_handle.wait_bootstrapped()
 
         # It's possible that the _bootstrap(_inner) fails in the new Thread (e.g. Memory Error);
         # We have to clean `_limbo` and `_active` here to avoid inconsistent state as much as possible
-        if self._os_thread_handle.is_failed():
+        if not self._os_thread_handle.wait_running():
             with _active_limbo_lock:
                 _limbo.pop(self, None)
                 if self._ident:
@@ -1067,7 +1066,7 @@ def _bootstrap_inner(self):
             if _HAVE_THREAD_NATIVE_ID:
                 self._set_native_id()
             self._set_os_name()
-            self._os_thread_handle.set_bootstrapped()
+            self._os_thread_handle.set_running()
             with _active_limbo_lock:
                 _active[self._ident] = self
                 del _limbo[self]
@@ -1115,7 +1114,7 @@ def join(self, timeout=None):
         """
         if not self._initialized:
             raise RuntimeError("Thread.__init__() not called")
-        if not self._os_thread_handle.is_done() and not self._os_thread_handle.is_bootstrapped():
+        if not self._os_thread_handle.is_done() and not self._os_thread_handle.is_running():
             raise RuntimeError("cannot join thread before it is started")
         if self is current_thread():
             raise RuntimeError("cannot join current thread")
@@ -1178,7 +1177,7 @@ def is_alive(self):
 
         """
         assert self._initialized, "Thread.__init__() not called"
-        return self._os_thread_handle.is_bootstrapped() and not self._os_thread_handle.is_done()
+        return self._os_thread_handle.is_running() and not self._os_thread_handle.is_done()
 
     @property
     def daemon(self):
@@ -1201,7 +1200,7 @@ def daemon(self, daemonic):
             raise RuntimeError("Thread.__init__() not called")
         if daemonic and not _daemon_threads_allowed():
             raise RuntimeError('daemon threads are disabled in this interpreter')
-        if self._os_thread_handle.is_bootstrapped() or self._os_thread_handle.is_done():
+        if self._os_thread_handle.is_running() or self._os_thread_handle.is_done():
             raise RuntimeError("cannot set daemon status of active thread")
         self._daemonic = daemonic
 
@@ -1443,7 +1442,7 @@ def __init__(self):
         _DeleteDummyThreadOnDel(self)
 
     def is_alive(self):
-        if self._os_thread_handle.is_bootstrapped() and not self._os_thread_handle.is_done():
+        if self._os_thread_handle.is_running() and not self._os_thread_handle.is_done():
             return True
         raise RuntimeError("thread is not alive")
 

Modules/_threadmodule.c

@@ -140,7 +140,7 @@ typedef struct {
 
     PyMutex mutex;
 
-    PyEvent thread_is_bootstrapped;
+    PyEvent thread_is_running;
     // Set immediately before `thread_run` returns to indicate that the OS
     // thread is about to exit. This is used to avoid false positives when
     // detecting self-join attempts. See the comment in `ThreadHandle_join()`
@@ -233,7 +233,7 @@ ThreadHandle_new(void)
     self->os_handle = 0;
     self->has_os_handle = 0;
     self->thread_is_exiting = (PyEvent){0};
-    self->thread_is_bootstrapped = (PyEvent){0};
+    self->thread_is_running = (PyEvent){0};
     self->mutex = (PyMutex){_Py_UNLOCKED};
     self->once = (_PyOnceFlag){0};
     self->state = THREAD_HANDLE_NOT_STARTED;
@@ -326,7 +326,7 @@ _PyThread_AfterFork(struct _pythread_runtime_state *state)
         handle->once = (_PyOnceFlag){_Py_ONCE_INITIALIZED};
         handle->mutex = (PyMutex){_Py_UNLOCKED};
         _PyEvent_Notify(&handle->thread_is_exiting);
-        _PyEvent_Notify(&handle->thread_is_bootstrapped);
+        _PyEvent_Notify(&handle->thread_is_running);
         llist_remove(node);
         remove_from_shutdown_handles(handle);
     }
@@ -400,7 +400,7 @@ thread_run(void *boot_raw)
         }
         // Notify that bootstrap is done and failed (e.g. Memory error).
         set_thread_handle_state(handle, THREAD_HANDLE_FAILED);
-        _PyEvent_Notify(&handle->thread_is_bootstrapped);
+        _PyEvent_Notify(&handle->thread_is_running);
     }
     else {
         Py_DECREF(res);
@@ -719,10 +719,10 @@ PyThreadHandleObject_join(PyObject *op, PyObject *args)
 }
 
 static PyObject *
-PyThreadHandleObject_is_bootstrapped(PyObject *op, PyObject *Py_UNUSED(dummy))
+PyThreadHandleObject_is_running(PyObject *op, PyObject *Py_UNUSED(dummy))
 {
     PyThreadHandleObject *self = PyThreadHandleObject_CAST(op);
-    if (_PyEvent_IsSet(&self->handle->thread_is_bootstrapped)) {
+    if (_PyEvent_IsSet(&self->handle->thread_is_running)) {
         Py_RETURN_TRUE;
     }
     else {
@@ -731,33 +731,26 @@ PyThreadHandleObject_is_bootstrapped(PyObject *op, PyObject *Py_UNUSED(dummy))
 }
 
 static PyObject *
-PyThreadHandleObject_wait_bootstrapped(PyObject *op, PyObject *Py_UNUSED(dummy))
+PyThreadHandleObject_wait_running(PyObject *op, PyObject *Py_UNUSED(dummy))
 {
     PyThreadHandleObject *self = PyThreadHandleObject_CAST(op);
-    PyEvent_Wait(&self->handle->thread_is_bootstrapped);
-    Py_RETURN_NONE;
+    PyEvent_Wait(&self->handle->thread_is_running);
+    if (get_thread_handle_state(self->handle) == THREAD_HANDLE_FAILED) {
+        Py_RETURN_FALSE;
+    }
+    else {
+        Py_RETURN_TRUE;
+    }
 }
 
 static PyObject *
-PyThreadHandleObject_set_bootstrapped(PyObject *op, PyObject *Py_UNUSED(dummy))
+PyThreadHandleObject_set_running(PyObject *op, PyObject *Py_UNUSED(dummy))
 {
     PyThreadHandleObject *self = PyThreadHandleObject_CAST(op);
-    _PyEvent_Notify(&self->handle->thread_is_bootstrapped);
+    _PyEvent_Notify(&self->handle->thread_is_running);
     Py_RETURN_NONE;
 }
 
-static PyObject *
-PyThreadHandleObject_is_failed(PyObject *op, PyObject *Py_UNUSED(dummy))
-{
-    PyThreadHandleObject *self = PyThreadHandleObject_CAST(op);
-    if (get_thread_handle_state(self->handle) == THREAD_HANDLE_FAILED) {
-        Py_RETURN_TRUE;
-    }
-    else {
-        Py_RETURN_FALSE;
-    }
-}
-
 static PyObject *
 PyThreadHandleObject_is_done(PyObject *op, PyObject *Py_UNUSED(dummy))
 {
@@ -791,10 +784,9 @@ static PyGetSetDef ThreadHandle_getsetlist[] = {
 static PyMethodDef ThreadHandle_methods[] = {
     {"join", PyThreadHandleObject_join, METH_VARARGS, NULL},
     {"_set_done", PyThreadHandleObject_set_done, METH_NOARGS, NULL},
-    {"wait_bootstrapped", PyThreadHandleObject_wait_bootstrapped, METH_NOARGS, NULL},
-    {"set_bootstrapped", PyThreadHandleObject_set_bootstrapped, METH_NOARGS, NULL},
-    {"is_bootstrapped", PyThreadHandleObject_is_bootstrapped, METH_NOARGS, NULL},
-    {"is_failed", PyThreadHandleObject_is_failed, METH_NOARGS, NULL},
+    {"wait_running", PyThreadHandleObject_wait_running, METH_NOARGS, NULL},
+    {"set_running", PyThreadHandleObject_set_running, METH_NOARGS, NULL},
+    {"is_running", PyThreadHandleObject_is_running, METH_NOARGS, NULL},
     {"is_done", PyThreadHandleObject_is_done, METH_NOARGS, NULL},
     {0, 0}
 };
@@ -2522,7 +2514,7 @@ thread__make_thread_handle(PyObject *module, PyObject *identobj)
     hobj->handle->ident = ident;
     hobj->handle->state = THREAD_HANDLE_RUNNING;
     PyMutex_Unlock(&hobj->handle->mutex);
-    _PyEvent_Notify(&hobj->handle->thread_is_bootstrapped);
+    _PyEvent_Notify(&hobj->handle->thread_is_running);
     return (PyObject*) hobj;
 }