// 基于 JDK 21 (本地 java.base 源), java.util.concurrent.ScheduledThreadPoolExecutor
public class ScheduledThreadPoolExecutor
        extends ThreadPoolExecutor
        implements ScheduledExecutorService {

    // 构造：maximumPoolSize 写死 Integer.MAX_VALUE，但队列无界，永远不会创建超过 core 的线程
    // ——所以 max 参数在这个池里是摆设，线程数只由 corePoolSize 决定
    public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE,
              DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,   // keepAlive=10ms，只为 corePoolSize=0 的病态用法兜底
              new DelayedWorkQueue());
    }

    private class ScheduledFutureTask<V>
            extends FutureTask<V> implements RunnableScheduledFuture<V> {

        /** Sequence number to break ties FIFO */
        private final long sequenceNumber;     // time 相同时按提交顺序，保证堆排序的全序

        /** The nanoTime-based time when the task is enabled to execute. */
        private volatile long time;            // 绝对触发时刻(nanoTime 基准)，不是剩余延迟

        // period 一个字段编码三种任务：>0 固定速率(fixedRate)，<0 固定间隔(fixedDelay)，=0 一次性
        private final long period;

        /** The actual task to be re-enqueued by reExecutePeriodic */
        RunnableScheduledFuture<V> outerTask = this;    // 若被 decorateTask 包装过，重新入队的是包装后的对象

        // 记住自己在堆数组里的下标 -> cancel 时 O(log n) 删除，不用 O(n) 线性找
        int heapIndex;

        // ...（构造器省略：就是给上面几个字段赋值）

        public long getDelay(TimeUnit unit) {
            return unit.convert(time - System.nanoTime(), NANOSECONDS);
        }

        public int compareTo(Delayed other) {   // 堆的排序依据：先比触发时刻，再比序号
            if (other == this) // compare zero if same object
                return 0;
            if (other instanceof ScheduledFutureTask) {
                ScheduledFutureTask<?> x = (ScheduledFutureTask<?>)other;
                long diff = time - x.time;      // 用差值比较而非 <，防 nanoTime 环绕出错
                if (diff < 0)
                    return -1;
                else if (diff > 0)
                    return 1;
                else if (sequenceNumber < x.sequenceNumber)
                    return -1;
                else
                    return 1;
            }
            long diff = getDelay(NANOSECONDS) - other.getDelay(NANOSECONDS);
            return (diff < 0) ? -1 : (diff > 0) ? 1 : 0;
        }

        public boolean isPeriodic() {
            return period != 0;
        }

        // fixedRate 和 fixedDelay 的分岔点就在这四行
        private void setNextRunTime() {
            long p = period;
            if (p > 0)
                time += p;                  // 固定速率：上次"应该"触发的时刻 + 周期，与实际执行耗时无关
            else
                time = triggerTime(-p);     // 固定间隔：now + 间隔，从"本轮跑完"起算
        }

        /**
         * Overrides FutureTask version so as to reset/requeue if periodic.
         */
        public void run() {
            if (!canRunInCurrentRunState(this))
                cancel(false);
            else if (!isPeriodic())
                super.run();                    // 一次性任务：正常 FutureTask 流程，跑完进终态
            else if (super.runAndReset()) {     // 周期任务：跑完把 state 复位回 NEW，可再跑
                setNextRunTime();               // 关键：抛异常时 runAndReset 返回 false，
                reExecutePeriodic(outerTask);   // 这两行不执行 -> 周期任务静默停止！
            }
        }
    }

    private void delayedExecute(RunnableScheduledFuture<?> task) {
        if (isShutdown())
            reject(task);
        else {
            super.getQueue().add(task);     // 先入队再保证有线程，和 TPE 的"先开线程"相反：任务还没到点，开了也白等
            if (!canRunInCurrentRunState(task) && remove(task))
                task.cancel(false);
            else
                ensurePrestart();           // 核心线程不足 core 就补一个（不带首任务启动）
        }
    }

    // 周期任务的重新入队：与 delayedExecute 同思路，但 shutdown 时静默丢弃而非 reject
    void reExecutePeriodic(RunnableScheduledFuture<?> task) {
        if (canRunInCurrentRunState(task)) {
            super.getQueue().add(task);
            if (canRunInCurrentRunState(task) || !remove(task)) {   // 入队后二次检查，防 shutdown 竞态
                ensurePrestart();
                return;
            }
        }
        task.cancel(false);
    }

    // 延迟 -> 绝对触发时刻。clamp 到 MAX_NANOS(约146年)防溢出
    long triggerTime(long delay) {
        return System.nanoTime() + Math.min(delay, MAX_NANOS);
    }

    public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
                                                  long initialDelay,
                                                  long period,
                                                  TimeUnit unit) {
        if (command == null || unit == null)
            throw new NullPointerException();
        if (period <= 0L)
            throw new IllegalArgumentException();
        ScheduledFutureTask<Void> sft =
            new ScheduledFutureTask<Void>(command,
                                          null,
                                          triggerTime(initialDelay, unit),
                                          unit.toNanos(period),     // 正数 -> fixedRate
                                          sequencer.getAndIncrement());
        RunnableScheduledFuture<Void> t = decorateTask(command, sft);
        sft.outerTask = t;
        delayedExecute(t);
        return t;
    }

    public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
                                                     long initialDelay,
                                                     long delay,
                                                     TimeUnit unit) {
        if (command == null || unit == null)
            throw new NullPointerException();
        if (delay <= 0L)
            throw new IllegalArgumentException();
        ScheduledFutureTask<Void> sft =
            new ScheduledFutureTask<Void>(command,
                                          null,
                                          triggerTime(initialDelay, unit),
                                          -unit.toNanos(delay),     // 与 fixedRate 在源码上的唯一差别：period 取负
                                          sequencer.getAndIncrement());
        RunnableScheduledFuture<Void> t = decorateTask(command, sft);
        sft.outerTask = t;
        delayedExecute(t);
        return t;
    }
}

// 基于 JDK 21 (本地 java.base 源), java.util.concurrent.Executors
public class Executors {

    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());  // 无参构造 = 容量 Integer.MAX_VALUE
    }                                                                        // 任务堆积无上限 -> OOM 风险

    public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
        return new AutoShutdownDelegatedExecutorService                     // 包装一层，屏蔽 setCorePoolSize 等调参入口
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>(),    // 同样是无界队列
                                    threadFactory));
    }

    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,                 // 线程数无上限
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());    // 零容量队列：没有空闲线程就立刻开新线程
    }                                                                       // 突发流量 -> 线程数爆炸

    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);   // 即上文：DelayedWorkQueue 无界 + max 形同虚设
    }

    public static ScheduledExecutorService newSingleThreadScheduledExecutor() {
        return new DelegatedScheduledExecutorService
            (new ScheduledThreadPoolExecutor(1));
    }
}