There is a race between when `Thread._tstate_lock` is released[^1] in `Thread._wait_for_tstate_lock()`and when `Thread._stop()` asserts[^2] that it is unlocked. Consider the following executioninvolving threads A, B, and C:1. A starts.2. B joins A, blocking on its `_tstate_lock`.3. C joins A, blocking on its `_tstate_lock`.4. A finishes and releases its `_tstate_lock`.5. B acquires A's `_tstate_lock` in `_wait_for_tstate_lock()`, releases it, but is swapped   out before calling `_stop()`.6. C is scheduled, acquires A's `_tstate_lock` in `_wait_for_tstate_lock()` but is swapped   out before releasing it.7. B is scheduled, calls `_stop()`, which asserts that A's `_tstate_lock` is not held.   However, C holds it, so the assertion fails.The race can be reproduced[^3] by inserting sleeps at the appropriate points inthe threading code. To do so, run the `repro_join_race.py` from the linked repo.There are two main parts to this PR:1. `_tstate_lock` is replaced with an event that is attached to `PyThreadState`.   The event is set by the runtime prior to the thread being cleared (in the same   place that `_tstate_lock` was released). `Thread.join()` blocks waiting for the   event to be set.2. `_PyInterpreterState_WaitForThreads()` provides the ability to wait for all   non-daemon threads to exit. To do so, an `is_daemon` predicate was added to   `PyThreadState`. This field is set each time a thread is created. `threading._shutdown()`   now calls into `_PyInterpreterState_WaitForThreads()` instead of waiting on   `_tstate_lock`s.[^1]:https://github.com/python/cpython/blob/441affc9e7f419ef0b68f734505fa2f79fe653c7/Lib/threading.py#L1201[^2]:https://github.com/python/cpython/blob/441affc9e7f419ef0b68f734505fa2f79fe653c7/Lib/threading.py#L1115[^3]:mpage@8194653---------Co-authored-by: blurb-it[bot] <43283697+blurb-it[bot]@users.noreply.github.com>Co-authored-by: Antoine Pitrou <antoine@python.org>

There is a race between when `Thread._tstate_lock` is released[^1] in `Thread._wait_for_tstate_lock()`and when `Thread._stop()` asserts[^2] that it is unlocked. Consider the following executioninvolving threads A, B, and C:1. A starts.2. B joins A, blocking on its `_tstate_lock`.3. C joins A, blocking on its `_tstate_lock`.4. A finishes and releases its `_tstate_lock`.5. B acquires A's `_tstate_lock` in `_wait_for_tstate_lock()`, releases it, but is swapped   out before calling `_stop()`.6. C is scheduled, acquires A's `_tstate_lock` in `_wait_for_tstate_lock()` but is swapped   out before releasing it.7. B is scheduled, calls `_stop()`, which asserts that A's `_tstate_lock` is not held.   However, C holds it, so the assertion fails.The race can be reproduced[^3] by inserting sleeps at the appropriate points inthe threading code. To do so, run the `repro_join_race.py` from the linked repo.There are two main parts to this PR:1. `_tstate_lock` is replaced with an event that is attached to `PyThreadState`.   The event is set by the runtime prior to the thread being cleared (in the same   place that `_tstate_lock` was released). `Thread.join()` blocks waiting for the   event to be set.2. `_PyInterpreterState_WaitForThreads()` provides the ability to wait for all   non-daemon threads to exit. To do so, an `is_daemon` predicate was added to   `PyThreadState`. This field is set each time a thread is created. `threading._shutdown()`   now calls into `_PyInterpreterState_WaitForThreads()` instead of waiting on   `_tstate_lock`s.[^1]:https://github.com/python/cpython/blob/441affc9e7f419ef0b68f734505fa2f79fe653c7/Lib/threading.py#L1201[^2]:https://github.com/python/cpython/blob/441affc9e7f419ef0b68f734505fa2f79fe653c7/Lib/threading.py#L1115[^3]:mpage@8194653---------Co-authored-by: blurb-it[bot] <43283697+blurb-it[bot]@users.noreply.github.com>Co-authored-by: Antoine Pitrou <antoine@python.org>

There is a race between when `Thread._tstate_lock` is released[^1] in `Thread._wait_for_tstate_lock()`and when `Thread._stop()` asserts[^2] that it is unlocked. Consider the following executioninvolving threads A, B, and C:1. A starts.2. B joins A, blocking on its `_tstate_lock`.3. C joins A, blocking on its `_tstate_lock`.4. A finishes and releases its `_tstate_lock`.5. B acquires A's `_tstate_lock` in `_wait_for_tstate_lock()`, releases it, but is swapped   out before calling `_stop()`.6. C is scheduled, acquires A's `_tstate_lock` in `_wait_for_tstate_lock()` but is swapped   out before releasing it.7. B is scheduled, calls `_stop()`, which asserts that A's `_tstate_lock` is not held.   However, C holds it, so the assertion fails.The race can be reproduced[^3] by inserting sleeps at the appropriate points inthe threading code. To do so, run the `repro_join_race.py` from the linked repo.There are two main parts to this PR:1. `_tstate_lock` is replaced with an event that is attached to `PyThreadState`.   The event is set by the runtime prior to the thread being cleared (in the same   place that `_tstate_lock` was released). `Thread.join()` blocks waiting for the   event to be set.2. `_PyInterpreterState_WaitForThreads()` provides the ability to wait for all   non-daemon threads to exit. To do so, an `is_daemon` predicate was added to   `PyThreadState`. This field is set each time a thread is created. `threading._shutdown()`   now calls into `_PyInterpreterState_WaitForThreads()` instead of waiting on   `_tstate_lock`s.[^1]:https://github.com/python/cpython/blob/441affc9e7f419ef0b68f734505fa2f79fe653c7/Lib/threading.py#L1201[^2]:https://github.com/python/cpython/blob/441affc9e7f419ef0b68f734505fa2f79fe653c7/Lib/threading.py#L1115[^3]:mpage@8194653---------Co-authored-by: blurb-it[bot] <43283697+blurb-it[bot]@users.noreply.github.com>Co-authored-by: Antoine Pitrou <antoine@python.org>

…hon 3.13`Thread._is_stopped` was removed inpython/cpython#114839 in Python 3.13(cherry picked from commit d568bc288aed00268ffeef137b9b901f480964ef)IJ-MR-137093GitOrigin-RevId: aa8b27b09db85f69b44d6fbbd333f8ec32489d33