Fix a flaky test

Follow-up for #4227

This time, the fix is less likely to work just by accident.
With enough loop iterations if we close the pool
after each iteration, the current `develop` fails in 10/10 runs,
whereas after this fix, running the test for 20 runs didn't fail
once.

kotlinx-coroutines-core/jvm/test/JobChildStressTest.kt

@@ -8,7 +8,7 @@ import kotlin.test.*
 /**
  * Testing the procedure of attaching a child to the parent job.
  */
-class JobChildStressTest : TestBase() {
+class JobChildStressTest : TestBase {
     private val N_ITERATIONS = 10_000 * stressTestMultiplier
     private val pool = newFixedThreadPoolContext(3, "JobChildStressTest")
 
@@ -77,6 +77,7 @@ class JobChildStressTest : TestBase() {
     fun testChildAttachmentRacingWithLastChildCompletion() {
         // All exceptions should get aggregated here
         repeat(N_ITERATIONS) {
+            val canCloseThePool = CountDownLatch(1)
             runBlocking {
                 val rogueJob = AtomicReference<Job?>()
                 /** not using [createCompletableDeferredForTesting] because we don't need extra children. */
@@ -89,21 +90,20 @@ class JobChildStressTest : TestBase() {
                 launch(pool + deferred) {
                     deferred.complete(Unit) // Transition deferred into "completing" state waiting for current child
                     // **Asynchronously** submit task that launches a child so it races with completion
-                    try {
-                        pool.executor.execute {
-                            rogueJob.set(launch(pool + deferred) {
-                                throw TestException("isCancelled: ${coroutineContext.job.isCancelled}")
-                            })
-                        }
-                    } catch (_: RejectedExecutionException) {
-                        // This is expected if the pool is closed
+                    pool.executor.execute {
+                        rogueJob.set(launch(pool + deferred) {
+                            throw TestException("isCancelled: ${coroutineContext.job.isCancelled}")
+                        })
+                        canCloseThePool.countDown()
                     }
                 }
 
                 deferred.join()
                 val rogue = rogueJob.get()
                 if (rogue?.isActive == true) {
                     throw TestException("Rogue job $rogue with parent " + rogue.parent + " and children list: " + rogue.parent?.children?.toList())
+                } else {
+                    canCloseThePool.await()
                 }
             }
         }