FutureTask类（源码解读）

太过爱你忘了你带给我的痛 2024-04-17 05:43 79阅读 0赞

**目录**

一.源码解读

1.1 FutureTask(Callable callable)

1.2 FutureTask(Runnable runnable, V result)

1.3 FutureTask类的一些常量和属性

1.3.1 任务当前状态 state

1.3.2 任务7种状态属性：

1.3.3 存放返回结果 outcome：

1.3.4 指向传入的实现了Callable接口的对象索引 callable

1.3.5 运行Callable的线程 runner

1.3.6 一个带向链表结构的线程链表中的一个节点（此部分博主还不太明白）

1.4 6个public修饰的方法

1.4.1 isCancelled()

1.4.2 isDone()

1.4.3 cancel()

1.4.4 get()

1.4.5 get(long timeout, TimeUnit unit)

1.4.6 run()

1.5 5个private修饰的方法

1.5.1 finishCompletion()

1.5.2 awaitDone(boolean timed, long nanos)

1.5.3 removeWaiter(WaitNode node)

1.5.4 report(int s)

1.5.5 handlePossibleCancellationInterrupt(int s)

1.6 4个protected修饰的方法

1.6.1 set()

1.6.2 setException(Throwable t)

1.6.3 done()

1.6.4 runAndReset()

1.7 静态代码块

1.8 静态内部类

--------------------

FutureTask类实现了RunnableFuture接口相关功能。[RunnableFuture接口源码解读][RunnableFuture]

此类的对象可以看成是一个可以对任务进行一些操作的实体，或者封装。

它的构造函数接收一个任务，可以看成接收一个工人，一个线程，而这个类就是相当于钢铁侠的战衣，他可以让工人拥有更多的能力。而这个类的名字 翻译也就是未来任务的意思。

FutureTask类中：

> 2个有参构造器。
> 
> 6个public修饰的方法。
> 
> 5个private修饰的私有方法。
> 
> 4个protected修饰的方法
> 
> 1个静态内部类。
> 
> 1个静态代码块。

# 一.源码解读 #

先来看看此类的两个有参的构造器

## **1.1 FutureTask(Callable<V> callable)** ##

/**
         * Creates a {@code FutureTask} that will, upon running, execute the
         * given {@code Callable}.
         *
         * @param  callable the callable task
         * @throws NullPointerException if the callable is null
         */
        public FutureTask(Callable<V> callable) {
            if (callable == null)
                throw new NullPointerException();
            this.callable = callable;
            this.state = NEW;       // ensure visibility of callable
        }

此构造器作用是传入一个实现了Callable接口的的任务类，初始化该**FutureTask**能操作的任务类**。**

## **1.2 FutureTask(Runnable runnable, V result)** ##

/**
         * Creates a {@code FutureTask} that will, upon running, execute the
         * given {@code Runnable}, and arrange that {@code get} will return the
         * given result on successful completion.
         *
         * @param runnable the runnable task
         * @param result the result to return on successful completion. If
         * you don't need a particular result, consider using
         * constructions of the form:
         * {@code Future<?> f = new FutureTask<Void>(runnable, null)}
         * @throws NullPointerException if the runnable is null
         */
        public FutureTask(Runnable runnable, V result) {
            this.callable = Executors.callable(runnable, result);
            this.state = NEW;       // ensure visibility of callable
        }

如上图此构造器的作用是传入一个实现了Runnable接口的任务类，并设置当此任务类运行完成后，任务类需要向调用此类的get方法的对象返回的 结果（result）。

此构造器会调用Executors类的静态方法 **callable(Runnable task, T result) 如下图**

/**
         * Returns a {@link Callable} object that, when
         * called, runs the given task and returns the given result.  This
         * can be useful when applying methods requiring a
         * {@code Callable} to an otherwise resultless action.
         * @param task the task to run
         * @param result the result to return
         * @param <T> the type of the result
         * @return a callable object
         * @throws NullPointerException if task null
         */
        public static <T> Callable<T> callable(Runnable task, T result) {
            if (task == null)
                throw new NullPointerException();
            return new RunnableAdapter<T>(task, result);
        }

而此静态方法会返回一个实现了Executors中的静态内部类:**RunnableAdapter。如下图**

/**
         * A callable that runs given task and returns given result
         */
        static final class RunnableAdapter<T> implements Callable<T> {
            final Runnable task;
            final T result;
            RunnableAdapter(Runnable task, T result) {
                this.task = task;
                this.result = result;
            }
            public T call() {
                task.run();
                return result;
            }
        }

如上图可以看见，此类就是实现了Callable接口，使得实现Runnable的类也能获取返回值，虽然此返回值是初始化任务时设置的。之前只实现Runnable接口的类，线程执行完这些类后是不会有返回值的。此RunnableAdapter<T>也是对适配器模式的实现.

以上模块我们能知道，此构造器的作用就是让只实现了Runnable接口的任务类，也能拥有我们设置的result返回值。类型是个泛型。因此返回的对象很宽泛，并不是说只能返回字符串等。

**由于当前FutureTask类实现了RunnableFuture接口，当然需要实现它对应的功能，看完构造器，我们来看看他public修饰的方法。来看看这些方法可以对传入的（实现了Callable或Runnable的）任务类做出那些操作。**

**以下对传入的任务类统称任务X（不论实现了什么接口的任务类）**

## **1.3** FutureTask**类的一些常量和属性** ##

/**
         * The run state of this task, initially NEW.  The run state
         * transitions to a terminal state only in methods set,
         * setException, and cancel.  During completion, state may take on
         * transient values of COMPLETING (while outcome is being set) or
         * INTERRUPTING (only while interrupting the runner to satisfy a
         * cancel(true)). Transitions from these intermediate to final
         * states use cheaper ordered/lazy writes because values are unique
         * and cannot be further modified.
         *
         * Possible state transitions:
         * NEW -> COMPLETING -> NORMAL
         * NEW -> COMPLETING -> EXCEPTIONAL
         * NEW -> CANCELLED
         * NEW -> INTERRUPTING -> INTERRUPTED
         */
        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;

在进入第1.4之前我们需要先了解一下此类的一些属性和字段。

上图的属性都被private修饰，意义它们是此类自己使用的属性，不对外暴露。

### 1.3.1 任务当前状态 **state** ###

首先第一个state，顾名思义，为当前任务X的状态。它被volatile修饰，意义是同时只能被一个线程操作他的状态。

注意注释中说明了只有这四种状态的变化：

1   \* NEW -> COMPLETING -> NORMAL  
  2   \* NEW -> COMPLETING -> EXCEPTIONAL  
  3   \* NEW -> CANCELLED  
  4   \* NEW -> INTERRUPTING -> INTERRUPTED

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NTE5MDQx_size_16_color_FFFFFF_t_70][]

### 1.3.2 任务7种状态属性： ###

> **NEW**：代表此任务X正在从调用start（）方法到任务正在运行的状态。
> 
> **COMPLETING**：代表此任务X运行结束，返回结果的时候，此时结果还未装载到outcome字段中（下面会提到）。完成中！
> 
> **NORMAL**：代表任务X执行成功，outcome字段保存正常返回值。
> 
> **EXCEPTIONAL**：代表任务X执行抛异常，outcome字段保存异常信息。
> 
> **CANCELLED**：任务X从start（）方法开始到任务运行完成之前，用户调用了cancel（false）方法。因为cancel（false）会允许正在执行任务的线程执行完任务。所以任务最后会被执行完。所以从cancel（false）方法被调用到任务执行完毕。任务状态都会被置为CANCELLED。 请参考future接口中cancel的定义：[Future接口（源码解读）][Future]
> 
> **INTERRUPTING**：任务X从start（）方法开始到任务运行完成之前，用户调用了cancel（true）方法。此方法会调用interrupt（）方法把中断标志置为true。当线程轮询到此标志位为true时，会做相关操作，比如真正的中断线程。例如说执行return或其他操作，抛出异常等。有关interrupt（）方法可以参考博客：（先做个假链接，这里我要是忘了写，你们要么提醒我一下，要么百度一下）。
> 
> 而在调用cancel（true）方法到任务被中断之前，状态标志位为INTERRUPTING
> 
> **INTERRUPTED**：当线程被真正中断后，任务的状态标志为此标志。

### 1.3.3 存放返回结果 **outcome**： ###

> /\*\* The result to return or exception to throw from get() \*/  
> private Object outcome; // non-volatile, protected by state reads/writes

### 1.3.4 指向传入的实现了Callable接口的对象索引 **callable** ###

> /\*\* The underlying callable; nulled out after running \*/
> 
> private Callable<V> callable;

### 1.3.5 运行Callable的线程 runner ###

> /\*\* The thread running the callable; CASed during run() \*/  
> private volatile Thread runner;

### 1.3.6 一个带向链表结构的线程链表中的一个节点（此部分博主还不太明白） ###

>     /\*\* Treiber stack of waiting threads \*/  
>     private volatile WaitNode waiters;

## 1.4 6个Public修饰的方法 ##

### 1.4.1 isCancelled() ###

当任务状态大于等于CANCELLED时，返回true。

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

### 1.4.2 isDone() ###

当任务状态只要不等于NEW时，返回true。由此可以说明，除了NEW的状态，都可视为任务已经运行完成了。至于完成成功与失败不做考虑。

public boolean isDone() {
            return state != NEW;
        }

### 1.4.3 cancel() ###

实现了future接口的方法，此FutureTask类实现了RunnableFuture接口，而RunnableFuture接口又继承了future接口。future接口中有**cancel**方法。

public boolean cancel(boolean mayInterruptIfRunning) {
            if (!(state == NEW &&
                  UNSAFE.compareAndSwapInt(this, stateOffset, 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();
                    } finally { // final state
                        UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED);
                    }
                }
            } finally {
                finishCompletion();
            }
            return true;
        }

首先我们来看一下这个方法的第一个if判断：

**当任务X当前状态不为NEW时**，这里是个&&，因此后面的compareAndSwapInt方法并不会执行。

cancel方法直接返回false。

**（1）意味着任务X当前的状态不为NEW时，不能使用cancel方法，cancel方法不会执行任何操作并返回false。**

**当任务X当前的状态为NEW时**，我们再来看看这个方法。

> **UNSAFE.compareAndSwapInt(this, stateOffset, NEW,  
>                   mayInterruptIfRunning ? INTERRUPTING : CANCELLED)**

这个方法是Unsafe类的（native）本地方法。也是对CAS思想的实现。关于CAS：

/**
         * Atomically update Java variable to <tt>x</tt> if it is currently
         * holding <tt>expected</tt>.
         * @return <tt>true</tt> if successful
         */
        public final native boolean compareAndSwapInt(Object o, long offset,
                                                      int expected,
                                                      int x);

此方法的意思是，当存放对象**o**中偏移量为**offset**的值与期望值**excepted**相等时，把对象**o**中偏移量为**offset**的值修改为**x**。

至此我们返回上面的if判断：

**（2）**意味着**任务X当前的状态为NEW时，**且传入的**mayInterruptIfRunning**为false时。任务的状态被切换为**CANCELLED**

且继续运行try部分代码，此时**mayInterruptIfRunning**为false，所以直接执行finally代码块中的finishCompletion()方法：

这里我们转到1.5.9节。好了看完finishCompletion()方法我们知道了只要执行cancel方法，那么waiters链表中所有节点的任务都会被取消。

**（3）**意味着**任务X当前的状态为NEW时，**且传入的**mayInterruptIfRunning**为true时。任务的状态被切换为**INTERRUPTING****。**并且告知线程需要被中断。执行了interrupt方法。这里我们继续来看看UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED);

/** Ordered/Lazy version of {@link #putIntVolatile(Object, long, int)}  */
        public native void    putOrderedInt(Object o, long offset, int x);

这个方法也是一个本地方法，意味着让虚拟机去设置内存屏障，避免指令重排序。作用是把offset位置的值修改为x。而且只有当offset位置的值被volatile修饰时，它被更新为x后才能立即从工作内存刷新到主内存中，这里大家应该能发现1.3.1中state就是被volatile修饰的。这里我们需要了解JMM的知识。

当然在这里就是把状态更新为**INTERRUPTED**

**看完上面3点，我们走完了1.3.1中第3种和第4种状态变化。**

### 1.4.4 get() ###

/**
         * @throws CancellationException {@inheritDoc}
         */
        public V get() throws InterruptedException, ExecutionException {
            int s = state;
            if (s <= COMPLETING)
                s = awaitDone(false, 0L);
            return report(s);
        }

这方法是实现父接口的父接口future中的get方法。调用此方法的线程会阻塞到得到任务返回的结果。

里面用了awaitDone方法：**请看1.6.1。**

**此方法意味着当任务未完成时才会去调用awaitDone的方法，看完1.6.1我们也知道，此方法会在大于**COMPLETING时返回任务状态。其他状态要么yield要么park了。当大于COMPLETING状态时（可再次查看1.3.1查看状态变化）不进入awaitDone方法直接返回状态。因为只要完成之后，状态就更新了，可以直接返回状态。

### 1.4.5 get(long timeout, TimeUnit unit) ###

/**
         * @throws CancellationException {@inheritDoc}
         */
        public V get(long timeout, TimeUnit unit)
            throws InterruptedException, ExecutionException, TimeoutException {
            if (unit == null)
                throw new NullPointerException();
            int s = state;
            if (s <= COMPLETING &&
                (s = awaitDone(true, unit.toNanos(timeout))) <= COMPLETING)
                throw new TimeoutException();
            return report(s);
        }

此方法和get无参方法差不多，只是当任务未结束时，已经到达了等待时间，那么会抛出超时异常。

### 1.4.6 run() ###

public void run() {
            if (state != NEW ||
                !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                             null, Thread.currentThread()))
                return;
            try {
                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;
                        setException(ex);
                    }
                    if (ran)
                        set(result);
                }
            } finally {
                // runner must be non-null until state is settled to
                // prevent concurrent calls to run()
                runner = null;
                // state must be re-read after nulling runner to prevent
                // leaked interrupts
                int s = state;
                if (s >= INTERRUPTING)
                    handlePossibleCancellationInterrupt(s);
            }
        }

实现了接口的方法，此方法才是核心运行任务的方法，看源码，它首先判断任务是否为NEW，不为NEW就直接返回了，从此可知，重复运行run方法是没有用的，同一个任务只运行一次。

如果当前的执行Callable的线程runner为null，那么他会让当前线程去成为runner。执行Callable。这也是run的意义。当然如果不为null，已经有runner去执行任务了，那么也直接run方法也直接return。

try块中的代码就是执行Callable的call方法。并获取结果result。不抛异常就调用set方法，那么我们来看一下set方法：见1.7.1节

那么当抛出异常我们需要调用setException()方法：

## 1.5 5个private修饰的方法 ##

### 1.5.1 finishCompletion() ###

此方法是私有的供FutureTask类自己使用，它的作用是释放waiters单链表中所有节点的线程和任务资源。

/**
         * Removes and signals all waiting threads, invokes done(), and
         * nulls out callable.
         */
        private void finishCompletion() {
            // assert state > COMPLETING;
            for (WaitNode q; (q = waiters) != null;) {
                if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) {
                    for (;;) {//循环完所有waiters链表的节点，让线程置空，并唤醒它。
                        Thread t = q.thread;
                        if (t != null) {
                            q.thread = null;
                            LockSupport.unpark(t);
                        }
                        WaitNode next = q.next;
                        if (next == null)
                            break;
                        q.next = null; // unlink to help gc
                        q = next;
                    }
                    break;
                }
            }
    
            done();
    
            callable = null;        // to reduce footprint
        }

在看这个方法的源码之前我们先看一下静态代码块部分，看完静态代码块部分我们看for循环，这个for循环首先定义一个WaitNode q，让他指向一个waiters节点，并且不能为空（这也是循环条件），；后不写任何自增的代码。接下来获取节点中的线程t，如果t不为空，那么让它变为空，接下来我们看看这个方法：LockSupport.unpark(t);

/**
         * Makes available the permit for the given thread, if it
         * was not already available.  If the thread was blocked on
         * {@code park} then it will unblock.  Otherwise, its next call
         * to {@code park} is guaranteed not to block. This operation
         * is not guaranteed to have any effect at all if the given
         * thread has not been started.
         *
         * @param thread the thread to unpark, or {@code null}, in which case
         *        this operation has no effect
         */
        public static void unpark(Thread thread) {
            if (thread != null)
                UNSAFE.unpark(thread);
        }

这方法就是对判断thread不为空才继续调用UNSAFE的unpark方法，我们再往下跟：

/**
         * Unblock the given thread blocked on <tt>park</tt>, or, if it is
         * not blocked, cause the subsequent call to <tt>park</tt> not to
         * block.  Note: this operation is "unsafe" solely because the
         * caller must somehow ensure that the thread has not been
         * destroyed. Nothing special is usually required to ensure this
         * when called from Java (in which there will ordinarily be a live
         * reference to the thread) but this is not nearly-automatically
         * so when calling from native code.
         * @param thread the thread to unpark.
         *
         */
        public native void unpark(Object thread);

看上图我们看见这又是一个native方法，此方法的作用是给传入此方法的thread线程一个许可，代表它可以苏醒了。不调用此方法，如果此方法调用了park方法，他将会一直被阻塞到park操作上。

继续回到上面的finishCompletion()方法。我们看见代码中q.thread = null; LockSupport.unpark(t);首先把节点的线程置空，再把线程唤醒，相当于是把节点线程的任务结束掉，再唤醒线程，那么线程就没有任务在执行了。继续往下看能知道后面的代码就是不断都往后遍历节点，并释放资源。把每个节点的next都置空也是为了JVM在进行可达性分析算法时，能回收掉相关资源。

**在这里我们不要忘了回到上面的cancel方法。我们也许是从那里跳过来的。**

### **1.5.2 awaitDone(boolean timed, long nanos)** ###

**此方法为一个等待任务执行结束并返回任务状态的作用。可以设置最大等待时间，超过等待时间，直接返回任务状态并结束任务。**

/**
         * Awaits completion or aborts on interrupt or timeout.
         *
         * @param timed true if use timed waits
         * @param nanos time to wait, if timed
         * @return state upon completion
         */
        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);
            }
        }

看以上源码能得知此方法通过传入的布尔变量timed判断是否要设置等待超时参数。timed为true时，通过当前系统时间加上传入的nano等待时长，得到死亡线时间，for循环中，先判断当前线程是否被中断，中断则移除任务节点，并报错。这里有removeWaiter()方法：请见1.5.3

如果未被中断，那么判断当前状态是否大于COMPLETING，大于时，返回任务状态，并释放线程。意味着当线程执行完成，如下图，**awaitDone方法会返回正常或异常的状态。**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NTE5MDQx_size_16_color_FFFFFF_t_70 1][]

代码继续往下看，当前状态是COMPLETING时，那么执行Thread.yield();让线程进入就绪状态与其他线程再次竞争运行机会。下面判断queue的状态，意味for死循环中只会执行一次 queued = UNSAFE.compareAndSwapObject(this, waitersOffset, q.next = waiters, q);这段代码。循环中没有让queue再变为false的代码。除非CAS失败，意思就是线程不断轮训查看waiters节点的状态，当任务完成后，就把waiters节点置空，并返回状态。如果设置了timed状态为true，那么当死亡线时间到达，会直接移除节点任务，并返回任务状态。最后，当以上所有状态都不满足时，此线程会被park方法阻塞。

这里记得返回get方法。此方法相当于就是对get方法的实现。

### **1.5.3** removeWaiter(WaitNode node) ###

这个方法的注释是：

**让超时的或中断的节点unlink掉也就是从这个链表中取出。来避免累计垃圾。**

当不使用CAS时，这些节点时不能分割的，所以当释放器去遍历时，是不会对链表有影响。

为避免已删除的节点分割对未分割节点的影响，链表会重新整理。整理的过程是缓慢的，所以链表不能过长以致超过整理所计划消耗的资源。

/**
         * Tries to unlink a timed-out or interrupted wait node to avoid
         * accumulating garbage.  Internal nodes are simply unspliced
         * without CAS since it is harmless if they are traversed anyway
         * by releasers.  To avoid effects of unsplicing from already
         * removed nodes, the list is retraversed in case of an apparent
         * race.  This is slow when there are a lot of nodes, but we don't
         * expect lists to be long enough to outweigh higher-overhead
         * schemes.
         */
        private void removeWaiter(WaitNode node) {
            if (node != null) {
                node.thread = null;
                retry:
                for (;;) {          // restart on removeWaiter race
                    for (WaitNode pred = null, q = waiters, s; q != null; q = s) {
                        s = q.next;
                        if (q.thread != null)
                            pred = q;
                        else if (pred != null) {
                            pred.next = s;
                            if (pred.thread == null) // check for race
                                continue retry;
                        }
                        else if (!UNSAFE.compareAndSwapObject(this, waitersOffset,
                                                              q, s))
                            continue retry;
                    }
                    break;
                }
            }
        }

### 1.5.4 report(int s) ###

/**
         * Returns result or throws exception for completed task.
         *
         * @param s completed state value
         */
        @SuppressWarnings("unchecked")
        private V report(int s) throws ExecutionException {
            Object x = outcome;
            if (s == NORMAL)
                return (V)x;
            if (s >= CANCELLED)
                throw new CancellationException();
            throw new ExecutionException((Throwable)x);
        }

此方法就是获取任务状态，并判断，当任务为正常完成NORMAL时返回状态，当任务s大于等于CANCELLED时，那么也许是4，5，6。当小于CANCELLED时也许是3，为什么没有0和1呢因为private修饰的report方法在每次调用的时候都已经判断大于COMPLETING  了 所以。这个report确实是对的，当状态为EXCEPTIONAL  就报执行异常ExecutionException((Throwable)x)

并抛出x异常信息，因为之前我们提到当状态为EXCEPTIONAL  时，会把异常信息装到任务状态中。可见setException方法。

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;

### 1.5.5 handlePossibleCancellationInterrupt(int s) ###

/**
         * Ensures that any interrupt from a possible cancel(true) is only
         * delivered to a task while in run or runAndReset.
         */
        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
    
            // assert state == INTERRUPTED;
    
            // We want to clear any interrupt we may have received from
            // cancel(true).  However, it is permissible to use interrupts
            // as an independent mechanism for a task to communicate with
            // its caller, and there is no way to clear only the
            // cancellation interrupt.
            //
            // Thread.interrupted();
        }

## 1.6 4个protected修饰的方法 ##

### 1.6.1 set() ###

/**
         * Sets the result of this future to the given value unless
         * this future has already been set or has been cancelled.
         *
         * <p>This method is invoked internally by the {@link #run} method
         * upon successful completion of the computation.
         *
         * @param v the value
         */
        protected void set(V v) {
            if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
                outcome = v;
                UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
                finishCompletion();
            }
        }

看完上面的内容，相信大家对这个UNSAFE里的方法很熟悉了。那么set方法就是把NEW状态更新为COMPLETING，更新成功就把v结果值赋值给outcome，赋值完成后，再把状态更新为NORMAL。最后释放各种资源调用finishCompletion方法。见1.5.9节。

**看完set方法，我们走完了1.3.1中第1种状态变化。**

### **1.6.2** setException(Throwable t) ###

/**
         * Causes this future to report an {@link ExecutionException}
         * with the given throwable as its cause, unless this future has
         * already been set or has been cancelled.
         *
         * <p>This method is invoked internally by the {@link #run} method
         * upon failure of the computation.
         *
         * @param t the cause of failure
         */
        protected void setException(Throwable t) {
            if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
                outcome = t;
                UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state
                finishCompletion();
            }
        }

如果我们看完了set方法再来看此方法，那么能知道它就是走的1.3.1节中的第二种状态。

相信看完这里我们已经走完了1.3.1节任务状态中的第4种状态。

### 1.6.3 done() ###

此方法是一个回调函数，虽然在本类中此方法没有任何实现，但是我们仔细观察会发现，此done方法在本类中被finishCompletion()方法释放所有资源后最后调用了(请见1.5.1）。然而finishCompletion()又被set方法(请见1.6.1)和setException(Throwable t)和cancel方法(请见1.4.3)调用。这3个方法我们看完就能知道他设置改变了1.3.1中说明会发生的4种状态变化。从而知道done方法会在每个流程走完的时候被调用，每种流程最后都调用了finishCompletion()，而finishCompletion()最后又会调用done。所以当子类实现此方法后，可以在这方法中写一些任务执行完需要执行的代码。finishCompletion()会去回调它。

/**
         * Protected method invoked when this task transitions to state
         * {@code isDone} (whether normally or via cancellation). The
         * default implementation does nothing.  Subclasses may override
         * this method to invoke completion callbacks or perform
         * bookkeeping. Note that you can query status inside the
         * implementation of this method to determine whether this task
         * has been cancelled.
         */
        protected void done() { }

栗子：task是传入实现了Runnable或Callable的任务（类）。

FutureTask<Integer> future = new FutureTask<Integer>(task) {
                @Override
                protected void done() {
                    try {
                        System.out.println("任务执行完毕，执行结果为:" + get());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (ExecutionException e) {
                        e.printStackTrace();
                    }
                }
            };

### 1.6.4 runAndReset() ###

此方法从名字上很好懂，运行并重置。**此方法在本类中没有被任何其他方法调用**。

先来看看它的注释：

在不设置结果的情况下执行计算，然后将此任务重置为初始状态，如果计算遇到异常或被取消，则无法执行此操作。这是为原本会执行多次的任务的需求而设计的。

意思就是当一个任务执行之后会改变一些运行前的环境，而不能重复运行任务，而这个方法就是保证每次run正常执行后，都能重置并再次运行。

/**
         * Executes the computation without setting its result, and then
         * resets this future to initial state, failing to do so if the
         * computation encounters an exception or is cancelled.  This is
         * designed for use with tasks that intrinsically execute more
         * than once.
         *
         * @return {@code true} if successfully run and reset
         */
        protected boolean runAndReset() {
            if (state != NEW ||
                !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                             null, Thread.currentThread()))
                return false;
            boolean ran = false;
            int s = state;
            try {
                Callable<V> c = callable;
                if (c != null && s == NEW) {
                    try {
                        c.call(); // don't set result
                        ran = true;
                    } catch (Throwable ex) {
                        setException(ex);
                    }
                }
            } finally {
                // runner must be non-null until state is settled to
                // prevent concurrent calls to run()
                runner = null;
                // state must be re-read after nulling runner to prevent
                // leaked interrupts
                s = state;
                if (s >= INTERRUPTING)
                    handlePossibleCancellationInterrupt(s);
            }
            return ran && s == NEW;
        }

一下代码我们在run方法中解释过了，是保证当前只有一个线程在运行任务，不论换哪一个线程来执行任务，任务都只有一个任务。如果当前没有线程执行本任务，那么把任务类中记录的运行本任务线程的变量置为本线程（此变量被存放在本类偏移量为runnerOffset的位置）。就是说没有线程运行本任务那么就由我来。

if (state != NEW ||
                !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                             null, Thread.currentThread()))
                return false;

此方法对比run方法，他关键的地方就是没有调用set方法。而set方法做了啥呢（参见1.6.1节）？他相当于让任务状态进行了 4种状态的第一种：

**NEW -> COMPLETING -> NORMAL**

如果不调用set方法的话，任务状态始终是NEW。所以我们能知道。runAndReset()的核心功能是，在运行完成后并不改变此任务的状态。以此达到多次运行的效果，比如当前有个需求是运行此任务4次算完成任务。那么前3次我可以调用runAndReset()，最后以此调用run()，从run方法或runAndReset中我们是能知道只有当状态为NEW时，任务才会运行的。其他状态时都会直接return了。

补充一下，为什么其他状态我们不考虑呢？因为其他状态要么是中断要么就是取消了，要么是异常了。只有正常运行完成我们才会继续任务对吧。因此才会在返回时有判断 return ran && s == NEW;代表ran要是true运行成功，并且没有被取消和中断。s需要判断为NEW才算reset。

## 1.7 静态代码块 ##

// Unsafe mechanics
        private static final sun.misc.Unsafe UNSAFE;
        private static final long stateOffset;
        private static final long runnerOffset;
        private static final long waitersOffset;
        static {
            try {
                UNSAFE = sun.misc.Unsafe.getUnsafe();
                Class<?> k = FutureTask.class;
                stateOffset = UNSAFE.objectFieldOffset
                    (k.getDeclaredField("state"));//获取当前k类中任务的状态属性偏移量
                runnerOffset = UNSAFE.objectFieldOffset
                    (k.getDeclaredField("runner"));//获取当前执行Callable方法的线程的偏移量
                waitersOffset = UNSAFE.objectFieldOffset
                    (k.getDeclaredField("waiters"));//获取k类的waiters等待线程节点偏移量
            } catch (Exception e) {
                throw new Error(e);
            }
        }

上面代码中可以看出，先获取到了FutureTask类的Class对象k。然后获取它的state属性，runner属性，waiters属性，的偏移量。这三个属性都能在类中源码看见。

## 1.8 静态内部类 ##

本类中执行任务的线程等待链表的一个节点的构造类。

/**
         * Simple linked list nodes to record waiting threads in a Treiber
         * stack.  See other classes such as Phaser and SynchronousQueue
         * for more detailed explanation.
         */
        static final class WaitNode {
            volatile Thread thread;
            volatile WaitNode next;
            WaitNode() { thread = Thread.currentThread(); }
        }

# 二.类的使用实践 #

待完善...

[RunnableFuture]: https://blog.csdn.net/qq_29519041/article/details/100039528
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NTE5MDQx_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/11/6468ca69e0724072a8a692b2cfd41665.png
[Future]: https://blog.csdn.net/qq_29519041/article/details/100034256
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NTE5MDQx_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/11/afd98eb04e32475fa1ceae47caacff7b.png