@@ -10,91 +10,24 @@
 NTHREADS = 10
 
 
-def _directory_scan_during_gc(directory, names):
-    import gc
-    import importlib.machinery
-    import json
-    import os
-    import threading
-    import time
-    from test import support
-
-    expected = set(names)
-    barrier = threading.Barrier(5)
-    stop = threading.Event()
-    errors = []
-    collections = []
-
-    def collect():
-        barrier.wait(timeout=support.LONG_TIMEOUT)
-        while not stop.is_set() and len(collections) < 512:
-            collections.append(gc.collect())
-            time.sleep(0.0001)
-
-    def scan():
-        barrier.wait(timeout=support.LONG_TIMEOUT)
-        for _ in range(256):
-            try:
-                assert set(os.listdir(directory)) == expected
-                with os.scandir(directory) as entries:
-                    assert {entry.name for entry in entries} == expected
-                finder = importlib.machinery.FileFinder(
-                    directory,
-                    (importlib.machinery.SourceFileLoader,
-                     importlib.machinery.SOURCE_SUFFIXES),
-                )
-                assert finder.find_spec('fixture') is not None
-            except BaseException as error:
-                errors.append(repr(error))
-
-    collector = threading.Thread(target=collect)
-    workers = [threading.Thread(target=scan) for _ in range(4)]
-    collector.start()
-    for worker in workers:
-        worker.start()
-    try:
-        for worker in workers:
-            worker.join(timeout=support.LONG_TIMEOUT)
-    finally:
-        stop.set()
-        collector.join(timeout=support.LONG_TIMEOUT)
-    assert not collector.is_alive()
-    assert all(not worker.is_alive() for worker in workers)
-    assert collections
-    return json.dumps(errors)
-
-
 @threading_helper.requires_working_threading()
 class TestOs(unittest.TestCase):
-    def test_directory_io_during_subinterpreter_gc(self):
-        from concurrent import interpreters
-        from test import support
-        from concurrent.futures import ThreadPoolExecutor
-        import json
+    def test_listdir_during_gc(self):
+        import gc
         from pathlib import Path
         import tempfile
 
-        names = ('fixture.py',) + tuple(f'file_{n:02d}.txt'
-                                       for n in range(32))
         with tempfile.TemporaryDirectory() as directory:
-            for name in names:
-                Path(directory, name).write_text('VALUE = 73\n')
-            for _ in range(16):
-                children = [interpreters.create() for _ in range(4)]
-                try:
-                    with ThreadPoolExecutor(max_workers=4) as pool:
-                        futures = [pool.submit(child.call,
-                                               _directory_scan_during_gc,
-                                               directory, names)
-                                   for child in children]
-                        results = [future.result(timeout=support.LONG_TIMEOUT)
-                                   for future in futures]
-                finally:
-                    for child in children:
-                        child.close()
-                for result in results:
-                    errors = json.loads(result)
-                    self.assertFalse(errors, errors[:3])
+            expected = {f"entry_{n}" for n in range(32)}
+            for name in expected:
+                Path(directory, name).touch()
+
+            def worker():
+                for _ in range(256):
+                    gc.collect()
+                    self.assertEqual(set(os.listdir(directory)), expected)
+
+            run_concurrently(worker, nthreads=4)
 
     @unittest.skipUnless(sysconfig.get_config_var('_Py_HAVE_STRERROR_R'),
                          'need _Py_HAVE_STRERROR_R macro')