Make Timeouts executor lazily initialized and re-creatable

Replace the static final ExecutorService with a lazily-created one so
that shutdown() doesn't permanently break subsequent container operations.
The executor is re-created transparently on next use.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: rnorth

core/src/main/java/org/testcontainers/utility/ducttape/Timeouts.java

@@ -9,20 +9,28 @@
  */
 public class Timeouts {
 
-    private static final ExecutorService EXECUTOR_SERVICE = Executors.newCachedThreadPool(new ThreadFactory() {
+    private static final AtomicInteger THREAD_COUNTER = new AtomicInteger(0);
 
-        final AtomicInteger threadCounter = new AtomicInteger(0);
+    private static final ThreadFactory THREAD_FACTORY = r -> {
+        Thread thread = new Thread(r, "ducttape-" + THREAD_COUNTER.getAndIncrement());
+        thread.setDaemon(true);
+        return thread;
+    };
 
-        @Override
-        public Thread newThread(Runnable r) {
-            Thread thread = new Thread(r, "ducttape-" + threadCounter.getAndIncrement());
-            thread.setDaemon(true);
-            return thread;
+    private static volatile ExecutorService executorService;
+
+    private static synchronized ExecutorService getExecutorService() {
+        if (executorService == null || executorService.isShutdown()) {
+            executorService = Executors.newCachedThreadPool(THREAD_FACTORY);
         }
-    });
+        return executorService;
+    }
 
-    public static void shutdown() {
-        EXECUTOR_SERVICE.shutdown();
+    public static synchronized void shutdown() {
+        if (executorService != null) {
+            executorService.shutdown();
+            executorService = null;
+        }
     }
 
     /**
@@ -40,7 +48,7 @@ public static <T> T getWithTimeout(final int timeout, final TimeUnit timeUnit, f
 
         check("timeout must be greater than zero", timeout > 0);
 
-        Future<T> future = EXECUTOR_SERVICE.submit(lambda);
+        Future<T> future = getExecutorService().submit(lambda);
         return callFuture(timeout, timeUnit, future);
     }
 
@@ -57,7 +65,7 @@ public static void doWithTimeout(final int timeout, final TimeUnit timeUnit, fin
 
         check("timeout must be greater than zero", timeout > 0);
 
-        Future<?> future = EXECUTOR_SERVICE.submit(lambda);
+        Future<?> future = getExecutorService().submit(lambda);
         callFuture(timeout, timeUnit, future);
     }
 

core/src/test/java/org/testcontainers/utility/TimeoutsShutdownTest.java

@@ -3,43 +3,33 @@
 import org.junit.Test;
 import org.testcontainers.utility.ducttape.Timeouts;
 
-import java.util.concurrent.RejectedExecutionException;
 import java.util.concurrent.TimeUnit;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 /**
- * POC demonstrating the bug in this PR's approach.
- *
- * <p>The PR adds {@code Timeouts.shutdown()} (which calls {@code EXECUTOR_SERVICE.shutdown()})
- * and invokes it from {@code GenericContainer.stop()}. Since {@code EXECUTOR_SERVICE} is a
- * static final field shared across all callers, shutting it down after stopping one container
- * permanently breaks all subsequent Timeouts usage — including wait strategies, startup checks,
- * and {@code Unreliables.retryUntilSuccess} for any container started afterwards.</p>
- *
- * <p><b>Note:</b> This test intentionally shuts down the shared Timeouts executor, which is
- * an irreversible operation within a single JVM. It should be run in its own Gradle test worker
- * (e.g. via {@code --tests} filter) to avoid affecting other tests.</p>
+ * Verifies that {@link Timeouts} works correctly across shutdown/reuse cycles.
+ * After {@code shutdown()} the executor is re-created on next use.
  */
-public class TimeoutsShutdownBugTest {
+public class TimeoutsShutdownTest {
 
-    /**
-     * Calls {@code Timeouts.shutdown()} (as {@code GenericContainer.stop()} does), then
-     * proves that subsequent Timeouts calls fail with {@link RejectedExecutionException}.
-     */
     @Test
-    public void shutdownBreaksSubsequentTimeoutCalls() {
-        // First call works fine — represents a container's wait strategy completing successfully
+    public void timeoutsWorkAfterShutdown() {
+        // First use
         String result1 = Timeouts.getWithTimeout(5, TimeUnit.SECONDS, () -> "container-1-ready");
         assertThat(result1).isEqualTo("container-1-ready");
 
-        // This is what GenericContainer.stop() does after stopping a container
+        // Shutdown (as GenericContainer.stop() does)
         Timeouts.shutdown();
 
-        // Second call — represents starting another container after the first was stopped.
-        // This fails because the static shared executor rejects new tasks after shutdown.
-        assertThatThrownBy(() -> Timeouts.getWithTimeout(5, TimeUnit.SECONDS, () -> "container-2-ready"))
-            .isInstanceOf(RejectedExecutionException.class);
+        // Second use — should transparently create a fresh executor
+        String result2 = Timeouts.getWithTimeout(5, TimeUnit.SECONDS, () -> "container-2-ready");
+        assertThat(result2).isEqualTo("container-2-ready");
+
+        // Shutdown and use again to confirm repeatable
+        Timeouts.shutdown();
+
+        String result3 = Timeouts.getWithTimeout(5, TimeUnit.SECONDS, () -> "container-3-ready");
+        assertThat(result3).isEqualTo("container-3-ready");
     }
 }