FutureTask 分析

 

FutureTask 功能：

由于FutureTask 同时实现Future和Runable接口，所有FutureTask代表一种支持异步计算的任务。

这里有两重概念，一个是获取异步计算结果，二是可执行的任务。

FutureTask 原理分析：

为了实现FutureTask 的两个功能，逐一进行分析。

1.获取异步计算结果：通过将无状态的结果，引入生命周期概念，进行状态化，来完成异步获取计算结果。

从FutureTask源码可以看出，通过引入状态state，状态化结果，完成计算结果异步获取。

2.可执行的任务：通过依赖注入Task，在JVM调用FutureTask的run方法时，调用注入Task的run方法，完成可执行的任务及结果的异步化。

但是这里有个问题，就是由于结果状态化后，就存在多线程并发问题，涉及到以下两个方面。

1. 多个线程同时获取异步结果，由于结果状态对外不可见，所以需要统一的处理方式应对，处理结果没有完成的情况。统一的做法是阻塞获取结果的线程。

2.结果最终是通过一个线程运行而来，为了避免不必要的资源浪费，最终应该只有一个线程运行计算结果的任务。

综上所述，其内部结构如下：

1. Callable callable
   内部封装的Callable对象。如果通过构造函数传的是Runnable对象，FutureTask会通过调用Executors#callable，把Runnable对象封装成一个callable。
2. Object outcome
   用于保存计算结果或者异常信息。
3. volatile Thread runner
   用来运行callable的线程。
4. volatile WaitNode waiters
   FutureTask中用了Trieber Stack来保存等待的线程。
5. 状态state

    /* Possible state transitions:
     * NEW -> COMPLETING -> NORMAL
     * NEW -> COMPLETING -> EXCEPTIONAL
     * NEW -> CANCELLED
     * NEW -> INTERRUPTING -> INTERRUPTED
     */

      状态变化如下图所示

 

通过分析源码get(),分析阻塞获取结果原理：

public V get() throws InterruptedException, ExecutionException {
        int s = state;
        if (s <= COMPLETING) // 根据共享变量状态决定阻塞等待还是返回结果
            s = awaitDone(false, 0L);//阻塞等待，直到结果状态为终态，返回结果
        return report(s);
 }

如何完成线程的阻塞等待? 这里简单总结：自旋+CAS+线程挂起.

通过自旋+CAS完成在多线程并发情况下加入Trieber Stack ，完成等待线程的入队。同时如果state状态满足跳出自旋，结束线程阻塞，通过线程挂起完成阻塞等待（唤醒在run()方法运行结束后调用 finishCompletion() 唤醒阻塞等待线程）

rivate 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();  /**该状态时间很短，让出CPU优先级，重新进行自旋**/
            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); /**挂起线程**/
        }
    }

通过分析源码run(),分析唤醒线程和计算结果原理：

由于run(),涉及唤醒线程和计算结果，所以应该只有一个线程运行该方法，这个需要特别注意。

public void run() {
        if (state != NEW ||
            !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                         null, Thread.currentThread()))
         /** 通过CAS操作设置多个并发线程中的一个线程为运行线程，最终在该线程中计算最终的结果*/
            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);
                   /**结果计算完毕设置state值并调用finishCompletion()唤醒等待线程*/
            }
        } 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);
        }
    }

finishCompletion() 源码分析 

 private void finishCompletion() {
        // assert state > COMPLETING;
        for (WaitNode q; (q = waiters) != null;) {
            /**设置等待队列为null，等待队列GC root不可达，will GC*/
            if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) {
                for (;;) {
                    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方法是暴露给子类的一个钩子方法。
     *
     * 这个方法在ExecutorCompletionService.QueueingFuture中的override实现是把结果加到阻塞队 
     * 列里。
     * CompletionService谁用谁知道，奥秘全在这。
     */
        done(); 

        callable = null;        // to reduce footprint
    }

 

引用：

https://cnblogs.com/micrari/p/7374513.html