// 基于本地 JDK 源码仓 (java.base, JDK 19+ 版本, 含 MhUtil), java.util.concurrent.FutureTask
public class FutureTask<V> implements RunnableFuture<V> {   // RunnableFuture = Runnable + Future：既能被 execute，又能被 get

    // 七态状态机。合法迁移只有四条路径，> COMPLETING 即尘埃落定：
    // NEW -> COMPLETING -> NORMAL          正常出结果
    // NEW -> COMPLETING -> EXCEPTIONAL     任务抛了异常
    // NEW -> CANCELLED                     cancel(false)
    // NEW -> INTERRUPTING -> INTERRUPTED   cancel(true)
    private volatile int state;
    private static final int NEW          = 0;
    private static final int COMPLETING   = 1;  // 瞬时态：outcome 正在写入的窗口期
    private static final int NORMAL       = 2;
    private static final int EXCEPTIONAL  = 3;
    private static final int CANCELLED    = 4;
    private static final int INTERRUPTING = 5;  // 瞬时态：cancel(true) 正在发中断
    private static final int INTERRUPTED  = 6;

    private Callable<V> callable;               // 任务结束后置 null，减小内存占用
    private Object outcome; // non-volatile, protected by state reads/writes    结果或异常，故意不加 volatile（见串讲）
    private volatile Thread runner;             // 正在执行任务的线程，run() 里 CAS 占坑
    private volatile WaitNode waiters;          // 等 get() 的线程组成的 Treiber 栈（头插无锁栈）

    // 终态之后把 outcome 翻译成三种结局：返回值 / CancellationException / ExecutionException
    @SuppressWarnings("unchecked")
    private V report(int s) throws ExecutionException {
        Object x = outcome;
        if (s == NORMAL)
            return (V)x;
        if (s >= CANCELLED)             // 状态值是按序精心排的：>= CANCELLED 的三个态都算"被取消"
            throw new CancellationException();
        throw new ExecutionException((Throwable)x);
    }

    public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;       // ensure visibility of callable    volatile 写压轴，顺带把 callable 安全发布出去
    }

    public boolean isCancelled() {
        return state >= CANCELLED;
    }

    public boolean isDone() {
        return state != NEW;    // 注意 COMPLETING 也算 done——所以 awaitDone 里见到 COMPLETING 不许空手返回
    }

    // 取消：只有还停在 NEW 的任务才有机会。mayInterruptIfRunning 决定走 CANCELLED 还是 INTERRUPTING 路线
    public boolean cancel(boolean mayInterruptIfRunning) {
        if (!(state == NEW && STATE.compareAndSet
              (this, NEW, mayInterruptIfRunning ? INTERRUPTING : CANCELLED)))
            return false;       // 已经在完成/取消路上，取消失败
        try {    // in case call to interrupt throws exception
            if (mayInterruptIfRunning) {
                try {
                    Thread t = runner;
                    if (t != null)
                        t.interrupt();          // 只是"请求"停止，call() 不响应中断就停不下来
                } finally { // final state
                    STATE.setRelease(this, INTERRUPTED);
                }
            }
        } finally {
            finishCompletion(); // 不管哪条路线，都要唤醒所有等 get 的线程
        }
        return true;
    }

    public V get() throws InterruptedException, ExecutionException {
        int s = state;
        if (s <= COMPLETING)            // NEW 或 COMPLETING 都还没法读 outcome，去等
            s = awaitDone(false, 0L);
        return report(s);
    }

    // ... 省略 get(timeout, unit) / resultNow / exceptionNow / state() / done()

    // run() 成功后调用：发布结果。CAS NEW->COMPLETING 是进入完成流程的唯一门票
    protected void set(V v) {
        if (STATE.compareAndSet(this, NEW, COMPLETING)) {
            outcome = v;                        // 普通写。此刻 state=COMPLETING，没有任何读方会碰 outcome
            STATE.setRelease(this, NORMAL); // final state      release 写：保证 outcome 先于 state 对外可见
            finishCompletion();
        }
    }

    // 任务抛异常时的发布路径，结构与 set 完全对称，outcome 存的是 Throwable
    protected void setException(Throwable t) {
        if (STATE.compareAndSet(this, NEW, COMPLETING)) {
            outcome = t;
            STATE.setRelease(this, EXCEPTIONAL); // final state
            finishCompletion();
        }
    }

    public void run() {
        if (state != NEW ||
            !RUNNER.compareAndSet(this, null, Thread.currentThread()))
            return;             // CAS runner 占坑失败 = 已有线程在跑，防止同一任务被并发执行
        try {
            Callable<V> c = callable;
            if (c != null && state == NEW) {    // 再查一次 state：占坑期间可能已被 cancel
                V result;
                boolean ran;
                try {
                    result = c.call();          // 真正干活的地方
                    ran = true;
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                    setException(ex);           // 异常不往外抛，存进 outcome——线程池里任务异常"无声"的根源
                }
                if (ran)
                    set(result);
            }
        } finally {
            // runner must be non-null until state is settled to
            // prevent concurrent calls to run()
            runner = null;      // 必须等 state 定局才清，否则空窗期另一线程能 CAS 占坑重跑
            // state must be re-read after nulling runner to prevent
            // leaked interrupts
            int s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }

    // 确保 cancel(true) 的中断只落在本任务执行期间，不泄漏给 worker 线程的下一个任务
    private void handlePossibleCancellationInterrupt(int s) {
        // It is possible for our interrupter to stall before getting a
        // chance to interrupt us.  Let's spin-wait patiently.
        if (s == INTERRUPTING)
            while (state == INTERRUPTING)
                Thread.yield(); // wait out pending interrupt   自旋等 cancel 线程把中断发完
        // ... 省略注释：不清中断标志，因为无法区分"取消中断"和"业务自己用的中断"
    }
}