update test case

Author: LindaSummer

Lib/test/test_free_threading/test_dict.py

@@ -4,9 +4,8 @@
 import weakref
 
 from ast import Or
-from collections import deque
 from functools import partial
-from threading import Barrier, Event, Thread
+from threading import Barrier, Thread
 from unittest import TestCase
 
 try:
@@ -344,45 +343,38 @@ def test_racing_dict_update_and_method_lookup_with_inline_values(self):
         class Target:
             pass
 
-        def appender(obj: Target, start: Barrier, stop: Event) -> None:
+        def appender(obj: Target, start: Barrier, iter_times: int) -> None:
             start.wait()
             index = 0
-            while not stop.is_set():
+            for _ in range(iter_times):
                 setattr(obj, f"probe_{index}", index)
                 index += 1
                 time.sleep(0)
 
-        def replacer(obj: Target, start: Barrier, stop: Event,
-                     detached_dict_queue: deque[tuple[dict, frozenset]]) -> None:
+        def replacer(obj: Target, start: Barrier, iter_times: int,
+                     detached_dict_queue: list[tuple[dict, frozenset]]) -> None:
             start.wait()
-            while not stop.is_set():
+            for _ in range(iter_times):
                 dict_snapshot = obj.__dict__
                 obj.__dict__ = {}
                 current_keys = frozenset(dict_snapshot)
                 detached_dict_queue.append((dict_snapshot, current_keys))
                 time.sleep(0)
 
-        def start_race(start: Barrier, stop: Event, seconds: float) -> None:
-            start.wait()
-            time.sleep(seconds)
-            stop.set()
-
-        def race(seconds: float, appender_threads: int,
+        def race(iter_times: 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 + 1)
-            stop = Event()
-            detached_dict_queue: deque[tuple[dict, frozenset]] = deque()
-            threads = [Thread(target=start_race, args=(start, stop, seconds),
-                              name="starter")]
+            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, stop),
+                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, stop, detached_dict_queue),
+                threads.append(Thread(target=replacer, args=(obj, start, iter_times, detached_dict_queue),
                                       name="replacer"))
 
             with threading_helper.start_threads(threads):
@@ -393,10 +385,10 @@ def race(seconds: float, appender_threads: int,
                                  f"Detached dict keys {set(dict_snapshot)} " +
                                  f"do not match current keys {current_keys}")
 
-        WAIT_FOR_SECONDS = 5
+        ITER_TIMES = 50_000
         APPENDER_THREADS = 8
         REPLACER_THREADS = 8
-        race(WAIT_FOR_SECONDS, APPENDER_THREADS, REPLACER_THREADS)
+        race(ITER_TIMES, APPENDER_THREADS, REPLACER_THREADS)
 
 if __name__ == "__main__":
     unittest.main()