Java8 FutureTask 分析

实现FutureTask的要点

1.需要实现一个链表(每个节点包含当前线程的引用)

2.通过LockSupport.park 对线程进行阻塞

3.节点的唤醒(task完成, 线程Interrupt, 或await超时),

FutureTask.run 方法

public void run() {
        // 判断 state 是否是new, 防止并发重复执行
        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{ // 调用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 方法(这是实现并发链表中移除队列节点的一个操作)

/**
     * 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操作)

debug代码：

public class TestFutureTask {

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

        /**
         * 第一种方式:Future + ExecutorService
         * Task task = new Task();
         * ExecutorService service = Executors.newCachedThreadPool();
         * Future<Integer> future = service.submit(task1);
         * service.shutdown();
         */

        /**
         * 第二种方式: FutureTask + ExecutorService
         * ExecutorService executor = Executors.newCachedThreadPool();
         * Task task = new Task();
         * FutureTask<Integer> futureTask = new FutureTask<Integer>(task);
         * executor.submit(futureTask);
         * executor.shutdown();
         */

        /**
         * 第三种方式:FutureTask + Thread
         */

        // 2. 新建FutureTask,需要一个实现了Callable接口的类的实例作为构造函数参数
        FutureTask<Integer> futureTask = new FutureTask<Integer>(new Task());
        // 3. 新建Thread对象并启动
        Thread thread = new Thread(futureTask);
        thread.setName("Task thread");
        thread.start();

        // 4. 调用isDone()判断任务是否结束
//        if(!futureTask.isDone()) {
//            System.out.println("Task is not done");
//            Thread.sleep(2000);
//        }

        // 5. 调用get()方法获取任务结果,如果任务没有执行完成则阻塞等待
        new Thread(()->{
            try {
                System.out.println("thread one result is " + futureTask.get());
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        }, "thread one").start();

        new Thread(()->{
            try {
                System.out.println("thread two result is " + futureTask.get(1, TimeUnit.SECONDS));
            } catch (InterruptedException | ExecutionException | TimeoutException e) {
                e.printStackTrace();
            }
        }, "thread two").start();

    }

    // 1. 继承Callable接口,实现call()方法,泛型参数为要返回的类型
    static class Task  implements Callable<Integer> {

        @Override
        public Integer call() throws Exception {
            System.out.println("Thread [" + Thread.currentThread().getName() + "] is running");
            int result = 0;
            for(int i = 0; i < 100;++i) {
                result += i;
            }

            Thread.sleep(20*1000);
            return result;
        }
    }
}

作者：爱吃鱼的KK
链接：https://www.jianshu.com/p/b765c0d0165d
來源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。