FutureTask 源码分析 (基于Java 8)

FutureTask 是java实现异步编程的基础
1. Future API
1) V get() throwsInterruptedException, ExecutionException;
     获取计算的结果, 若计算没完成, 直接 await, 直到 计算结束或线程中断
2) V get (long timeout, TimeUnit unit) throwsInterruptedException, ExecutionException, TimeoutException;
     获取计算的结果, 若计算没完成, 直接 await, 直到 计算结束或线程中断或time时间超时
3) boolean isDone();
     返回计算是否完成 , 若任务完成则返回true ( 任务完成 state = narmal, exception, interrupted)
4) int awaitDone(boolean timed, long nanos)    throws InterruptedException
     等待任务完成, 或时间超时, 返回值是 future 的state的状态(**await是实现future的重要方法**)
2.以下以一个FutureTask实现cache的例子来进行介绍
// 常用connection接口
public interface Connection {
    String getName();
}

// abstract cache 类
public abstract class AbstractLocalCache {

    protected Logger logger = Logger.getLogger(getClass());

    /** 本地缓存存储地址 */
    private ConcurrentHashMap> pool = new ConcurrentHashMap<>();

    private ExecutorService executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() + 1);

    // 模版方法
    public abstract V computeV(K k);

    public Future getResult(K k){
        Future result = null;
        if(pool.containsKey(k)){
            return pool.get(k);
        }
        FutureTask future = new FutureTask(new Callable() {
            @Override
            public V call() throws Exception {
                return computeV(k);
            }
        });

        // 说明map中以前没有对应的 futureTask
        // 仔细体会 putIfAbsent 的作用
        if(pool.putIfAbsent(k, future) == null){
            executorService.submit(future);
        }
        return future;
    }
}

// connection cache
public class LocalCacheConnection extends AbstractLocalCache {

    @Override
    public Connection computeV(String s) {

        logger.info("创建connection开始");
        logger.info("睡觉开始");

        try {
            Thread.sleep(3*1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        logger.info("睡觉结束");
        logger.info("创建connection结束");

        return new Connection() {
            @Override
            public String getName() {
                return s;
            }

            @Override
            public String toString() {
                return "A connection(" + s + ")";
            }
        };
    }
}

// future main 方法
public class FutureMain {

    private static final Logger logger = Logger.getLogger(FutureMain.class);

    public static void main(String[] args) throws Exception{

        LocalCacheConnection localCacheConnection = new LocalCacheConnection();
        Future future = localCacheConnection.getResult("connection");

        new Thread(){
            @Override
            public void run() {
                try {
                    logger.info("future.get() : " + future.get(2 , TimeUnit.SECONDS));
                } catch (Exception e) {
                    e.printStackTrace();
                }finally {
                    logger.info("future.get() over");
                }
            }
        }.start();

        new Thread(){
            @Override
            public void run() {
                try {
                    logger.info("future.get() : " + future.get(4, TimeUnit.SECONDS));
                } catch (Exception e) {
                    e.printStackTrace();
                }finally {
                    logger.info("future.get() over");
                }
            }
        }.start();
    }
}

计算结果 :

[2016-12-17 21:25:22,945] INFO  pool-1-thread-1 (LocalCacheConnection.java:11) - 创建connection开始
[2016-12-17 21:25:22,949] INFO  pool-1-thread-1 (LocalCacheConnection.java:12) - 睡觉开始
[2016-12-17 21:25:24,948] INFO  Thread-0 (FutureMain.java:31) - future.get() over
java.util.concurrent.TimeoutException
    at java.util.concurrent.FutureTask.get(FutureTask.java:205)
    at com.lami.tuomatuo.search.base.concurrent.future.example.FutureMain$1.run(FutureMain.java:27)
[2016-12-17 21:25:25,955] INFO  pool-1-thread-1 (LocalCacheConnection.java:20) - 睡觉结束
[2016-12-17 21:25:25,955] INFO  pool-1-thread-1 (LocalCacheConnection.java:21) - 创建connection结束
[2016-12-17 21:25:25,956] INFO  Thread-1 (FutureMain.java:40) - future.get() : A connection(connection)
[2016-12-17 21:25:25,957] INFO  Thread-1 (FutureMain.java:44) - future.get() over
3.FutureTask 的运行方式是这样的
  1. 将一个 Callable 置为 FutureTask 的内置成员
  2. 执行 Callable 中的 call 方法
  3. 调用futureTask.get(timeout, TimeUnit) 方法, 获取call的执行结果, 超时的话就报 TimeoutException

从上面可以看出: 只要将耗时的任务丢给FutureTask, 不必等待程序运行结束,继续往下执行, 从而实现程序异步执行的功能

看到上面的例子, 你可能会有疑问: 两个都是调用future.get(timeout, TimeUnit) 方法, 一个报异常, 一个确得到了结果, futureTask 的内部执行机制到底是什么??
(PS: 对了, 有这样的疑惑才能往代码的深处走)

我们都知道ExecutorService是个线程的工具类, 将FutureTask丢给它后会执行对应的run方法, 那我们就先看 FutureTask的run方法

FutureTask.run 方法
public void run() {
        // 判断 state 是否是new, 防止并发重复执行
        if(state != NEW ||
                !unsafe.compareAndSwapObject(this, runnerOffset, null, Thread.currentThread())){
            return;
        }

        try {
            Callable c = callable;
            if(c != null && state == NEW){
                V result ;
                boolean ran;
                try{ // 调用call方法执行计算
                    result = c.call();
                    ran = true;
                }catch (Throwable ex){
                    result = null;
                    ran = false;
                    // 执行中抛异常, 更新state状态, 释放等待的线程(调用finishCompletion)
                    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);
            }
        }
    }

这里看到state这个变量, 它是futureTask执行任务的状态(一个有7种)

  /**
     * 这几种状态比较重要, 下面是 FutureTask 中 state 的状态转变的几种情况
     * Possible state's transitions
     * NEW -> COMPLETING -> NORMAL
     * NEW -> COMPLETING -> EXCEPTIONAL
     * NEW -> CANCELLED
     * NEW -> INTERRUPTING -> INETRRUPTED
     */

    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;

而run其实没做什么, 就是执行 callable.call方法, 成功的话将执行结果调用set进行赋值, 并更新state的值(通过cas)

下面看例子中的 future.get(timeout,TimeUnit) 的源码
public V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
        // get(timeout, unit) 也很简单, 主要还是在 awaitDone里面
        if(unit == null){
            throw new NullPointerException();
        }
        int s = state;
        // 判断state状态是否 <= Completing, 调用awaitDone进行旋转
        if(s <= COMPLETING && (s = awaitDone(true, unit.toNanos(timeout))) <= COMPLETING){
            throw new TimeoutException();
        }
        // 根据state的值进行返回结果或抛出异常
        return report(s);
    }

get() 方法中涉及到 awaitDone 方法, 将awaitDone的运行结果赋值给state, 最后report方法根据state值进行返回相应的值, 而awaitDone是整个 FutureTask 运行的核心

那下面来看 awaitDone的方法
/**
     * Awaits completion or aborts on interrupt or timeout
     * 调用 awaitDone 进行线程的自旋
     * 自旋一般调用步骤
     *  1) 若支持线程中断, 判断当前的线程是否中断
     *      a. 中断, 退出自旋, 在线程队列中移除对应的节点
     *      b. 进行下面的步骤
     *  2) 将当前的线程构造成一个 WaiterNode 节点, 加入到当前对象的队列里面 (进行 cas 操作)
     *  3) 判断当前的调用是否设置阻塞超时时间
     *      a. 有 超时时间, 调用 LockSupport.parkNanos; 阻塞结束后, 再次进行 自旋 , 还是到同一个if, 但 nanos = 0L, 删除链表中对应的 WaiterdNode, 返回 state值
     *      b. 没 超时时间, 调用 LockSupport.park
     *
     * @param timed true if use timed waits
     * @param nanos time to waits, if timed
     * @return state upon completion
     */
    private int awaitDone(boolean timed, long nanos) throws InterruptedException{
        // default timed = false, nanos = 0, so deadline = 0
        final long deadline = timed ? System.nanoTime() + nanos : 0L;
        WaitNode q = null;
        boolean queued = false;
        for(;;){
            // Thread.interrupted 判断当前的线程是否中断(调用两次会清楚对应的状态位)
            // Thread.interrupt 将当前的线程设置成中断状态
            if(Thread.interrupted()){
                removeWaiter(q, Thread.currentThread().getId());
                throw new InterruptedException();
            }

            int s = state;
            /** 1. s = NORMAL, 说明程序执行成功, 直接获取对应的 V
             */
            if(s > COMPLETING){
                if(q != null){
                    q.thread = null;
                }
                return s;
            }
            // s = COMPLETING ; 看了全部的代码说明整个任务在处理的中间状态, s紧接着会进行改变
            // s 变成 NORMAL 或 EXCEPTION
            // 所以调用 yield 让线程状态变更, 重新进行CPU时间片竞争, 并且进行下次循环
            else if(s == COMPLETING){ // cannot time out yet
                Thread.yield();
            }
            // 当程序调用 get 方法时, 一定会调用一次下面的方法, 对 q 进行赋值
            else if(q == null){
                q = new WaitNode();
            }
            // 判断有没将当前的线程构造成一个节点, 赋值到对象对应的属性里面
            // 第一次 waiters 一定是 null 的, 进行赋值的是一个以 q 为首节点的栈(JUC里面还有一处用栈的就在 SynchronousQueue中)
            else if(!queued){
                queued = unsafe.compareAndSwapObject(this, waitersOffset, q.next = waiters, q);
            }
            // 调用默认的 get()时, timed = false, 所以不执行这一步
            else if(timed){
                // 进行阻塞时间的判断, 第二次循环时, nanos = 0L, 直接 removeWaiter 返回现在 FutureTask 的 state
                nanos = deadline - System.nanoTime();
                if(nanos <= 0L){
                    removeWaiter(q, Thread.currentThread().getId());
                    return state;
                }
                LockSupport.parkNanos(this, nanos);
            }
            // 进行线程的阻塞
            else{
                LockSupport.park(this);
            }
        }
    }

结合我们刚才例子(FutureMain)中的两个调用futureTask.get()方法

第一个futureTask.get(2. TimeUnit.SECOND), 因为执行的任务需要花费3秒, 所以它先会LockSupport.parkNanos(210001000*1000) 阻塞2秒, 之后再次进行同样的地方, 但nanos已是0, 所以调用removeWaiter方法, 最后抛出异常

第二个futureTask.get(4. TimeUnit.SECOND), 因为执行的任务需要花费3秒, 所以它先会LockSupport.parkNanos(410001000*1000) 阻塞4秒, 但是任务只花费3秒, 所以执行完成后会调用set方法进行赋值, 在set方法中有个finishCompletion方法, 这个方法会唤醒所有阻塞的节点, 所以第二个futureTask.get只花费3秒就得到了结果

分析一下 removeWaiter 方法(这是实现并发链表中移除队列节点的一个操作)
/**
     * 这个 removeWaiter 个人认为是最搞人的, 尤其在多线程环境中, 同时进行节点的删除
     * 时隔一个月回头再看, 下面的代码就是一个并发安全的栈中进行一个节点的删除操作
     * Tries to unlinked a time-out
     * @param node
     */
    private void  removeWaiter(WaitNode node, long i){
        logger.info("removeWaiter node"  + node +", i: "+ i +" begin");
        if(node != null){
            node.thread = null; // 将移除的节点的thread=null, 为移除做标示

            retry:
            for(;;){ // restart on removeWaiter race
                for(WaitNode pred = null, q = waiters, s; q != null; q = s){
                    logger.info("q : " + q +", i:"+i);
                    s = q.next;
                    // 通过 thread 判断当前 q 是否是需要移除的 q节点
                    if(q.thread != null){
                        pred = q;
                        logger.info("q : " + q +", i:"+i);
                    }
                    // 何时执行到这个if条件 ?
                    // hehe 只有第一步不满足时, 也就是q.thread=null (p就是应该移除的节点)
                    else if(pred != null){
                        logger.info("q : " + q +", i:"+i);
                        pred.next = s; // 将前一个节点的 next 指向当前节点的 next 节点
                        // pred.thread == null 这种情况是在多线程进行并发 removeWaiter 时产生的
                        // 而此时真好移除节点 node 和 pred, 所以loop跳到retry, 在进行一次
                        if(pred.thread == null){ // check for race
                            continue retry;
                        }
                    }
                    // 这一步何时操作呢?
                    // 想想 若p是头节点
                    else if(!unsafe.compareAndSwapObject(this, waitersOffset, q, s)){
                        logger.info("q : " + q +", i:"+i);
                        continue retry; // 这一步还是 cheak for race
                    }
                }
                break ;
            }
            logger.info("removeWaiter node"  + node +", i: "+ i +" end");
        }
    }

removeWaiter 这个方法我认为是最复杂的, 你需要考虑多种情况(1. 移除的节点是队列的头节点, 2. 移除的节点是队列中的中间节点, 3. 在并发情况下, 两个线程同时removeWaiter操作), 重要的地方我都加了注解

至此FutureTask的源码我们都差不多看到了, 总结一下实现Future的要点
1. 需要实现一个链表(每个节点包含当前线程的引用)
2. 通过 Thread.wait 或LockSupport.park 对线程进行阻塞
3. 有个公共方法进行节点的唤醒(task完成, 线程Interrupt, 或await超时), 并且次方法要线程安全

你可能感兴趣的:(FutureTask 源码分析 (基于Java 8))