Модель памяти free-threaded Python

Корректна ли данная программа? Всегда ли она должна завершится? (по мотивам вопроса Остановить потоки при завершениии программы)

import time
import threading

class Foo:
    def __init__(self, delay, count = 1):
        self._running = False
        self._delay = delay
        self._count = count
    def start(self):
        assert not self._running
        self._running = True
        self._threads = []
        for _ in range(self._count):
            self._threads.append(threading.Thread(target=self._work))
            self._threads[-1].start()
    def stop(self):
        assert self._running
        self._running = False
        for t in self._threads:
            t.join()
        print(f"{type(self).__name__} завершение работы {len(self._threads)}")
    def _is_running(self):
        return self._running
    def _work(self):
        while self._is_running():  # Не оптимально, но для сравнения
            if self._delay:
                print("_work(): цикл")
                time.sleep(self._delay)
    def __enter__(self):
        return self
    def __exit__(self, exc_type, exc_value, traceback):
        self.stop()

delay, count = 0, 7
with Foo(delay, count) as f:
    f.start()
    time.sleep(3*delay + 1)

Вроде бы, читая PEP 583 – A Concurrency Memory Model for Python можно подумать, что более менее (в отличие от C/C++/Java), впрочем он не слишком строг. Кроме того, всё таки он Withdrawn и от 2008 года, а при наличии GIL я в этой программе и не сомневаюсь.

Или для поддержки free-threaded Python обязательно необходимо стать более строгим?

import time
import threading

class Boo:
    def __init__(self, delay, count = 1):
        self._running = threading.Event()
        self._delay = delay
        self._count = count
    def start(self):
        assert not self._running.is_set()
        self._running.set()
        self._threads = []
        for _ in range(self._count):
            self._threads.append(threading.Thread(target=self._work))
            self._threads[-1].start()
    def stop(self):
        assert self._running.is_set()
        self._running.clear()
        for t in self._threads:
            t.join()
        print(f"{type(self).__name__} завершение работы {len(self._threads)}")
    def _is_running(self):
        return self._running.is_set()
    def _work(self):
        while self._is_running():  # Не оптимально, но для сравнения
            if self._delay:
                print("_work(): цикл")
                time.sleep(self._delay)
    def __enter__(self):
        return self
    def __exit__(self, exc_type, exc_value, traceback):
        self.stop()

delay, count = 0, 7
with Boo(delay, count) as b:
    b.start()
    time.sleep(3*delay + 1)

Смущает, что в Python не добавили поддержку атомарных переменных, поэтому вообще неясна необходимость модификаций. Возможно всё и так должно нормально работать, точно так же, как и в случае GIL?

К примеру, протоколы когерентности памяти для x86 (MESI, MOESI, ...), вроде как, не нарушают корректности первого варианта, даже если GIL отключен. За все ARM не скажу, хотя на некоторых он должен быть корректен.

А вот гарантии для всех платформ с поддержкой free-threaded Python, лично мне пока не понятны, то ли плохо искал и не нашёл нужного документа, то ли плохо прочитал имеющиеся (PEP583, PEP703).

Кроме того неясно достаточно ли threading.Event() близок к атомарным типам того же C++, нет ли у него проблем масштабирования метода is_set()? Или лучше использовать какой-нибудь иной примитив, типа, threading.Lock()?

P.S.

Цена вопроса:

import sys
assert 0 == sys.flags.gil
delay, count = 0, 15

for ttype in Foo, Boo, BooLock:
    with ttype(delay, count) as t:
        t.start()
        %timeit t._is_running()

Для macOS, Python 3.14t:

215 ns ± 9.87 ns per loop (mean ± std. dev. of 7 runs, 1,000,000 loops each)
Foo завершение работы 15
2.25 μs ± 34.3 ns per loop (mean ± std. dev. of 7 runs, 1,000,000 loops each)
Boo завершение работы 15
9.96 μs ± 307 ns per loop (mean ± std. dev. of 7 runs, 100,000 loops each)
BooLock завершение работы 15

1.94 μs ± 25.3 ns per loop (mean ± std. dev. of 7 runs, 1,000,000 loops each)
Foo завершение работы 150
22.8 μs ± 447 ns per loop (mean ± std. dev. of 7 runs, 100,000 loops each)
Boo завершение работы 150
1.38 ms ± 14.1 μs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)
BooLock завершение работы 150

Где BooLock использует with self._lock: return self._running.

Похоже под macOS threading.Event() ни разу не атомарный тип, хотя и без проблем масштабирования и существенно лучше чем threading.Lock().