FIx race

Author: pablogsal

Lib/test/test_external_inspection.py

@@ -893,48 +893,34 @@ def test_only_active_thread(self):
             sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
             sock.connect(('localhost', {port}))
 
-            def worker_thread(name, barrier, ready_event):
-                barrier.wait()  # Synchronize thread start
-                ready_event.wait()  # Wait for main thread signal
-                # Sleep to keep thread alive
+            def sleeping_thread():
                 time.sleep(10_000)
 
-            def main_work():
-                # Do busy work to hold the GIL
+            def busy_thread():
+                # Busy loop to hold the GIL
                 sock.sendall(b"working\\n")
                 count = 0
-                while count < 100000000:
+                while count < 100_000_000:
                     count += 1
-                    if count % 10000000 == 0:
-                        pass  # Keep main thread busy
                 sock.sendall(b"done\\n")
 
-            # Create synchronization primitives
-            num_threads = 3
-            barrier = threading.Barrier(num_threads + 1)  # +1 for main thread
-            ready_event = threading.Event()
+            # Start two sleeping threads
+            t1 = threading.Thread(target=sleeping_thread)
+            t2 = threading.Thread(target=sleeping_thread) 
+            t1.start()
+            t2.start()
 
-            # Start worker threads
-            threads = []
-            for i in range(num_threads):
-                t = threading.Thread(target=worker_thread, args=(f"Worker-{{i}}", barrier, ready_event))
-                t.start()
-                threads.append(t)
-
-            # Wait for all threads to be ready
-            barrier.wait()
+            # Start busy thread
+            t3 = threading.Thread(target=busy_thread)
+            t3.start()
 
             # Signal ready to parent process
             sock.sendall(b"ready\\n")
 
-            # Signal threads to start waiting
-            ready_event.set()
-
-            # Give threads time to start sleeping
-            time.sleep(0.1)
-
-            # Now do busy work to hold the GIL
-            main_work()
+            # Wait for threads to finish
+            t1.join()
+            t2.join()
+            t3.join()
             """
         )
 
@@ -956,13 +942,9 @@ def main_work():
                 client_socket, _ = server_socket.accept()
                 server_socket.close()
 
-                # Wait for ready signal
+                # Wait for ready signal and working signal
                 response = b""
-                while b"ready" not in response:
-                    response += client_socket.recv(1024)
-
-                # Wait for the main thread to start its busy work
-                while b"working" not in response:
+                while b"ready" not in response or b"working" not in response:
                     response += client_socket.recv(1024)
 
                 # Get stack trace with all threads
@@ -984,8 +966,8 @@ def main_work():
                 p.terminate()
                 p.wait(timeout=SHORT_TIMEOUT)
 
-            # Verify we got multiple threads in all_traces
-            self.assertGreater(len(all_traces), 1, "Should have multiple threads")
+            # Verify we got 3 threads in all_traces
+            self.assertEqual(len(all_traces), 4, "Should have exactly 4 threads")
 
             # Verify we got exactly one thread in gil_traces
             self.assertEqual(len(gil_traces), 1, "Should have exactly one GIL holder")
@@ -996,6 +978,5 @@ def main_work():
             self.assertIn(gil_thread_id, all_thread_ids,
                          "GIL holder should be among all threads")
 
-
 if __name__ == "__main__":
     unittest.main()