gh-151518: Simplify the GC fairness regression

Use explicit warmup imports and a joined non-daemon collector.
Run the child through script_helper with a faulthandler watchdog
so a stalled attachment still fails with a traceback.

Describe the bug as a fairness issue in the NEWS entry.

Author: tpn

Lib/test/test_free_threading/test_gc.py

@@ -1,7 +1,5 @@
 import unittest
 
-import subprocess
-import sys
 import textwrap
 import threading
 from threading import Thread
@@ -11,7 +9,7 @@
 import weakref
 
 from test import support
-from test.support import threading_helper
+from test.support import script_helper, threading_helper
 
 
 class MyObj:
@@ -214,20 +212,32 @@ def reader():
 
     @support.requires_subprocess()
     def test_tight_gc_loop_does_not_starve_attach(self):
-        script = textwrap.dedent("""
+        script = textwrap.dedent(f"""
+            import faulthandler
+
+            faulthandler.dump_traceback_later({support.SHORT_TIMEOUT}, exit=True)
+
             import gc
-            import importlib
             import threading
             import time
 
-            modules = (
-                "abc", "argparse", "collections", "contextlib",
-                "decimal", "enum", "functools", "heapq",
-                "importlib", "inspect", "itertools", "json",
-                "math", "operator", "random", "re",
-            )
-            for name in modules:
-                importlib.import_module(name)
+            # Add GC-tracked objects to lengthen the stop-the-world pauses.
+            import abc
+            import argparse
+            import collections
+            import contextlib
+            import decimal
+            import enum
+            import functools
+            import heapq
+            import importlib
+            import inspect
+            import itertools
+            import json
+            import math
+            import operator
+            import random
+            import re
 
             started = threading.Event()
             stop = threading.Event()
@@ -238,28 +248,17 @@ def collect():
                 while not stop.is_set():
                     gc.collect()
 
-            thread = threading.Thread(target=collect, daemon=True)
+            thread = threading.Thread(target=collect)
             thread.start()
             started.wait()
             # Each reattachment must make progress between consecutive pauses.
             for _ in range(50):
                 time.sleep(0.02)
             stop.set()
             thread.join()
+            faulthandler.cancel_dump_traceback_later()
         """)
-        proc = subprocess.run(
-            [sys.executable, "-I", "-X", "gil=0", "-X", "faulthandler",
-             "-c", script],
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True,
-            timeout=support.SHORT_TIMEOUT,
-        )
-        self.assertEqual(
-            proc.returncode,
-            0,
-            f"stdout:\n{proc.stdout}\nstderr:\n{proc.stderr}",
-        )
+        script_helper.assert_python_ok("-X", "gil=0", "-c", script)
 
 
 if __name__ == "__main__":

Misc/NEWS.d/next/Core_and_Builtins/2026-06-16-19-20-00.gh-issue-151518.e6v0Js.rst

@@ -1,2 +1,2 @@
-Fix a free-threaded stop-the-world race that could starve a thread reattaching
-after being suspended while detached.
+Fix a free-threaded stop-the-world fairness issue that could starve a thread
+reattaching after being suspended while detached.