FutureTask为何单个任务仅执行一次原理解析

public class Test {
    //计算结果
    int count=0;
    @Test
    public void test(){
        try{  
            FutureTask<Integer> futureTask=new FutureTask<>(new Callable<Integer>() {
                @Override
                public Integer call() throws Exception {
                    return 1;
                }
            });
            //把FutureTask放入线程中,线程会运行FutureTask的run()代码块
            Thread t1=new Thread(futureTask);
            t1.start();
            //获取计算的结果,是一个阻塞等待返回的方法
            count+=futureTask.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        //最后结果: 1
        System.out.println(count);    
    }
}

/**
    执行结果(全局变量), 有2种情况:
    1. 顺利完成返回的结果
    2. 执行run()代码块过程中抛出的异常
*/
private Object outcome; 
//正在执行run()的线程, 内存可被其他线程可见
private volatile Thread runner;
​​​​​​​public void run() {
    /**
        FutureTask的run()仅执行一次的原因：
        1. state != NEW表示任务正在被执行或已经完成, 直接return
        2. 若state==NEW, 则尝试CAS将当前线程 设置为执行run()的线程,如果失败,说明已经有其他线程 先行一步执行了run(),则当前线程return退出
    */
    if (state != NEW ||!UNSAFE.compareAndSwapObject(this, runnerOffset,null, Thread.currentThread()))
        return;
    try {
        //持有Callable的实例,后续会执行该实例的call()方法
        Callable<V> c = callable;
        if (c != null && state == NEW) {
            V result;
            boolean ran;
            try {
                result = c.call();
                ran = true;
            }catch (Throwable ex) {
                result = null;
                ran = false;
                //执行中抛的异常会放入outcome中保存
                setException(ex);
            }
            if (ran)
                //若无异常, 顺利完成的执行结果会放入outcome保存
                set(result);
        }
    }finally {
        // help GC 
        runner = null;
        int s = state;
        if (s >= INTERRUPTING)
            handlePossibleCancellationInterrupt(s);
    }
}

public V get() throws InterruptedException, ExecutionException {    
       int s = state;
       //COMPLETING: 正在完成的状态;  s <= COMPLETING就是未完成
    if (s <= COMPLETING)
        //不计时等待,结束等待的条件只有【完成】、【被中断】、【被取消】、【抛其他异常(不包括中断异常、取消异常)】
        s = awaitDone(false, 0L);
    return report(s);    
}

private volatile int state;
//线程创建状态
private static final int NEW = 0;
//完成(**一个瞬时的标记**)   
private static final int COMPLETING = 1;
//正常完成状态
private static final int NORMAL = 2;
//执行过程出现异常
private static final int EXCEPTIONAL = 3;
//执行过程中被取消
private static final int CANCELLED = 4;
//线程执行被中断(**一个瞬时的标记**)
private static final int INTERRUPTING = 5;
//线程执行被中断的状态
private static final int INTERRUPTED = 6;

/**
    @param timed 若是true则为定时等待,超时后会结束等待,并返回当前状态state
    @param nanos 如果是定时等待即第一个入参timed=true的话,会设置对应的等待时长
*/
private int awaitDone(boolean timed, long nanos) throws InterruptedException {
    //等待的最后期限
    final long deadline = timed ? System.nanoTime() + nanos : 0L;
    WaitNode q = null;
    boolean queued = false;
    //进入无限循环的等待状态,只有【完成】、【被取消】、【异常】、【中断】、【超时】这五种情况才会结束等待
    for (;;) {
        if (Thread.interrupted()) {
            //线程执行被中断,则移除等待结点并抛出异常
            removeWaiter(q);
            throw new InterruptedException();
        }
         int s = state;
        //【完成】、【被取消】、【抛其他异常】的状态都会 在这 结束等待
        if (s > COMPLETING) {
            if (q != null)
                q.thread = null;
            return s;
        }
        //子线程处于任务完成的瞬时状态,要等一会才能拿到执行结果
        else if (s == COMPLETING) // cannot time out yet
            Thread.yield();
        else if (q == null)
            q = new WaitNode();
        else if (!queued)
            queued = UNSAFE.compareAndSwapObject(this, waitersOffset, q.next = waiters, q);
        else if (timed) {
            //设置定时等待并且已经超时了
            nanos = deadline - System.nanoTime();
            if (nanos <= 0L) {
                removeWaiter(q);
                return state;
            }
            LockSupport.parkNanos(this, nanos);
        }
        else
            LockSupport.park(this);       
    }
}

/*正常的计算结果 or 抛出的异常 都会作为outcome*/
private Object outcome;
private V report(int s) throws ExecutionException {
    Object x = outcome;
    //正常完成
    if (s == NORMAL)
        return (V)x;
    //执行的过程中【被取消】
    if (s >= CANCELLED)
        throw new CancellationException();
    /**
        这里抛的是执行过程中发生的其他异常,既不是【中断异常】,也不是【被取消异常】
        比如发生了RuntimeException之类的就会在这抛
    */    
    throw new ExecutionException((Throwable)x);
}

public class FutureTask<V> implements RunnableFuture<V> {
    //执行任务并返回结果
    private Callable<V> callable;
    public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        //新建状态
        this.state = NEW;
    }
}