update test case

Author: LindaSummer

Lib/test/test_free_threading/test_dict.py

@@ -358,8 +358,8 @@ def writer():
 
     def test_racing_dict_update_and_method_lookup_with_inline_values(self):
         # gh-149816: sub-case 108
-        # The race below checks that setattr() does not write into a detached
-        # dict after __dict__ is replaced by another thread.
+        # The race below checks that a detached dict is still valid
+        # when racing setattr with __dict__ replacement
         class Target:
             pass
 
@@ -371,44 +371,46 @@ def appender(obj: Target, start: Barrier, iter_times: int) -> None:
                 index += 1
                 time.sleep(0)
 
-        def replacer(obj: Target, start: Barrier, iter_times: int,
-                     detached_dict_queue: list[tuple[dict, frozenset]]) -> None:
+        def replacer(obj: Target, start: Barrier, iter_times: int, churn_size: int) -> None:
             start.wait()
             for _ in range(iter_times):
-                dict_snapshot = obj.__dict__
+                old_dict = obj.__dict__
                 obj.__dict__ = {}
-                current_keys = frozenset(dict_snapshot)
-                detached_dict_queue.append((dict_snapshot, current_keys))
+                del old_dict
                 time.sleep(0)
-
-        def race(iter_times: int, appender_threads: int,
+                # create a list of dicts to trigger a realloc of the dict's table
+                # and ensure that the old dict is not used after it is deleted
+                realloc_trigger_list = [{"k": j} for j in range(churn_size)]
+                del realloc_trigger_list
+
+        def race(iter_times: int,
+                 churn_size: int,
+                 appender_threads: int,
                  replacer_threads: int) -> None:
             obj = Target()
             setattr(obj, "origin", 0)
             _ = obj.__dict__  # Access __dict__ to ensure it's initialized
 
             start = Barrier(appender_threads + replacer_threads)
-            detached_dict_queue: list[tuple[dict, frozenset]] = []
             threads = []
             for _ in range(appender_threads):
                 threads.append(Thread(target=appender, args=(obj, start, iter_times),
                                       name="appender"))
             for _ in range(replacer_threads):
-                threads.append(Thread(target=replacer, args=(obj, start, iter_times, detached_dict_queue),
+                threads.append(Thread(target=replacer, args=(obj, start, iter_times, churn_size),
                                       name="replacer"))
 
-            with threading_helper.start_threads(threads):
-                pass
-
-            for dict_snapshot, current_keys in detached_dict_queue:
-                self.assertEqual(set(dict_snapshot), current_keys,
-                                 f"Detached dict keys {set(dict_snapshot)} " +
-                                 f"do not match current keys {current_keys}")
+            with threading_helper.catch_threading_exception() as cm:
+                with threading_helper.start_threads(threads):
+                    pass
+                if cm.exc_type is not None:
+                    raise cm.exc_value
 
-        ITER_TIMES = 50_000
+        ITER_TIMES = 2_000
         APPENDER_THREADS = 8
         REPLACER_THREADS = 8
-        race(ITER_TIMES, APPENDER_THREADS, REPLACER_THREADS)
+        CHURN_SIZE = 512
+        race(ITER_TIMES, CHURN_SIZE, APPENDER_THREADS, REPLACER_THREADS)
 
 if __name__ == "__main__":
     unittest.main()

Misc/NEWS.d/next/Core_and_Builtins/2026-06-26-00-02-29.gh-issue-149816.JKN-5B.rst

@@ -1,3 +1,3 @@
 Fix a race in free-threaded builds where storing an instance attribute could
-write to a detached ``__dict__`` if another thread replaced ``obj.__dict__``
-concurrently.
+use a stale borrowed reference to an instance ``__dict__`` after another thread
+replaced it.