定时任务只跑一次就没了，线程池真的停了吗？

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

/** JDK 17; actual scheduler, bounded waits, no timing benchmark or persistent jobs. */
public class PeriodicFailureDemo {
    static final long LIMIT_SECONDS = 5;

    static void check(boolean condition, String message) {
        if (!condition) throw new AssertionError(message);
    }

    static void await(CountDownLatch latch, String label) throws InterruptedException {
        check(latch.await(LIMIT_SECONDS, TimeUnit.SECONDS), "timed out: " + label);
    }

    static final class KnownTemporaryFailure extends RuntimeException {
        KnownTemporaryFailure(String message) { super(message); }
    }

    public static void main(String[] args) throws Exception {
        ScheduledThreadPoolExecutor scheduler = new ScheduledThreadPoolExecutor(1);
        scheduler.setRemoveOnCancelPolicy(true);
        AtomicInteger brokenRuns = new AtomicInteger();
        AtomicInteger controlledRuns = new AtomicInteger();
        List<String> outcomes = new CopyOnWriteArrayList<>();
        AtomicReference<Throwable> unexpected = new AtomicReference<>();
        CountDownLatch completedTwo = new CountDownLatch(1);
        try {
            ScheduledFuture<?> broken = scheduler.scheduleAtFixedRate(() -> {
                brokenRuns.incrementAndGet();
                throw new IllegalStateException("deliberate periodic failure");
            }, 0, 10, TimeUnit.MILLISECONDS);

            Throwable cause;
            try {
                broken.get(LIMIT_SECONDS, TimeUnit.SECONDS);
                throw new AssertionError("periodic future returned normally");
            } catch (ExecutionException failure) {
                cause = failure.getCause();
            }
            check(cause instanceof IllegalStateException, "wrong failure cause");
            check(broken.isDone() && !broken.isCancelled(), "failure is not explicit cancellation");
            check(brokenRuns.get() == 1, "failed series should stop after first execution");

            String independent = scheduler.schedule(() -> "still alive", 0, TimeUnit.MILLISECONDS)
                    .get(LIMIT_SECONDS, TimeUnit.SECONDS);
            check(independent.equals("still alive"), "other task did not run");
            check(!scheduler.isShutdown(), "scheduler was unexpectedly shut down");
            System.out.println("failed series: runs=" + brokenRuns.get()
                    + " done=" + broken.isDone() + " cancelled=" + broken.isCancelled());
            System.out.println("failure cause: " + cause.getClass().getSimpleName());
            System.out.println("independent task: " + independent);

            // A policy for this known, side-effect-free demo failure only.
            ScheduledFuture<?> controlled = scheduler.scheduleWithFixedDelay(() -> {
                int attempt = controlledRuns.incrementAndGet();
                try {
                    if (attempt == 1) throw new KnownTemporaryFailure("fixture temporarily unavailable");
                    outcomes.add("attempt " + attempt + ": success");
                } catch (KnownTemporaryFailure known) {
                    outcomes.add("attempt " + attempt + ": failed; continue next tick");
                } catch (RuntimeException failure) {
                    unexpected.set(failure);
                    throw failure; // Unknown failure ends this periodic series.
                } finally {
                    if (attempt == 2) {
                        // Stop this demo's periodic series from inside its own task.
                        scheduler.shutdown();
                        completedTwo.countDown();
                    }
                }
            }, 0, 10, TimeUnit.MILLISECONDS);

            await(completedTwo, "two controlled attempts");
            check(scheduler.awaitTermination(LIMIT_SECONDS, TimeUnit.SECONDS), "scheduler did not stop");
            check(unexpected.get() == null, "unexpected task error");
            check(controlledRuns.get() == 2, "expected exactly two controlled attempts");
            check(outcomes.equals(List.of("attempt 1: failed; continue next tick", "attempt 2: success")),
                    "outcome log mismatch");
            check(controlled.isDone() && controlled.isCancelled(), "shutdown should cancel this series");
            for (String outcome : outcomes) System.out.println(outcome);
            System.out.println("controlled series: cancelled after two attempts=" + controlled.isCancelled());
            System.out.println("PASS: per-task failure, independent task, explicit continuation, clean shutdown");
        } finally {
            scheduler.shutdownNow();
            if (!scheduler.awaitTermination(LIMIT_SECONDS, TimeUnit.SECONDS)) {
                throw new AssertionError("worker did not terminate");
            }
        }
    }
}