Java FutureTask 源码解析

最新推荐文章于 2024-09-22 01:54:06 发布

haibing_blog

最新推荐文章于 2024-09-22 01:54:06 发布

阅读量528

点赞数 1

分类专栏： Java 基础文章标签： Java FutureTask AsyncTask

本文链接：https://blog.csdn.net/xhbxhbsq/article/details/53608164

版权

Java 基础专栏收录该内容

11 篇文章 0 订阅

订阅专栏

本文详细解析了Java的FutureTask，包括其属性、run()方法、cancel()方法的执行逻辑，以及任务结果回调方法done()和获取结果的方法get()的工作原理。重点探讨了cancel()方法在不同状态下对任务执行的影响，以及中断请求如何影响任务的执行。

摘要由CSDN通过智能技术生成

FutureTask注释

FutureTask一个可取消的异步计算。利用开始和取消计算的方法、查询计算是否完成的方法和获取计算结果的方法，此类提供了对Future的基本实现。仅在计算完成时才能获取结果；如果计算尚未完成，则阻塞get方法。一旦计算完成，就不能在重新开始或取消计算。

可使用FutureTask包装Callable或Runnable对象。因为Future实现了Runnable，所以可将Future提交给Executor执行。

FutureTask属性

FutureTask 有两个很重要的属性分别是 state runner ，futureTask之所以可以支持cancel操作就是因为这两个属性

其中state为枚举值：

NEW 新建 0

COMPLETING 执行中       1
NORMAL 正常           2
EXCEPTIONAL 异常           3
CANCELLED 取消 4
INTERRUPTING 中断中       5
INTERRUNPED 被中断       6

state的状态变化可以有四种方式

NEW->COMPLETING->NORMAL 正常完成的流程

NEW->COMPLETING->EXCEPTIONAL 出现异常的流程
NEW->CANCELED 被取消
NEW->INTERRUNPING->INTERRRUNPTED 被中断

我们研究下Task的状态变化也就是一个任务的生命周期:

我们创建一个FutureTask 首先会调用构造方法:

   
       public FutureTask(Runnable runnable, V result) {
        this.callable = Executors.callable(runnable, result);
        this.state = NEW;       // ensure visibility of callable
    }

在我们构造Task的时候会把状态设置成 NEW 也就是所有状态变化路径的起始状态

我们创建完一个Task 会提交给Executes来执行(当然我们也可以自己启动Thread来执行效果基本是一样，只是交给线程池执行Task可能会延迟执行）。

在之后的Task生命周期的变化主要取决于 run()方法先被调用还是cancel ()方法会被调用，这两个方法的执行顺序决定了Task的生命周期的四种走向。

FutureTask run()

我们先分析run方法先被调用的情况，为了能对run()方法能更加详细的理解我在run方法中加了增加了些注释

   
       public void run() {
        1、首先判断任务的状态 如果任务的状态不是new 说明任务的状态已经改变（说明他已经走了4种可能变化的一种） 
        2、如果状态是new就会把 当前执行任务的线程付给runner, 这里用的cmpandset如果runner不为空 说明已经有线程在执行 
        3、任务也会退出执行,如果状态是new并且runner为空并且把当前的线程付给了runner那么就继续执行任务(runner state 都是 volatile 类型的变量是一个很轻量机的线程安全操作) 
        4、引起state状态变化的原因 就是调用了cancel 或是 run 
        if (state != NEW ||
            !U.compareAndSwapObject(this, RUNNER, null, Thread.currentThread()))
            return;
        //开始执行任务  
        try {
            Callable<V> c = callable;
            // 如果 要执行的任务不为空 并且状态 new 就执行 
            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  
            runner = null;
            // state must be re-read after nulling runner to prevent
            // leaked interrupts
            int s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }

Task执行后如果成功会调用set()方法,如果有异常会调用setException()方法。

我们先看下set方法：

   
       protected void set(V v) {
        // 如果state是new 把state设置成 COMPLETING 
        if (U.compareAndSwapInt(this, STATE, NEW, COMPLETING)) {
            // 将结果保存到outcome
            outcome = v;
            // 将任务设置成NORMAL   over the task  
            U.putOrderedInt(this, STATE, NORMAL); // final state
            finishCompletion();
        }
    }

如果现在的状态是NEW 就把状态设置成COMPLETING 然后设置成NORMAL。这个执行流程导致的状态变化就是

NEW->COMPLETING->NORMAL

执行步骤是首先执行 run() 并且Task正常完成而且在这其间没有调用cancel()

上边是任务正常执行完成的状态变化，我们在看下有异常的情况。有异常的话会调用setException()方法:

   
       protected void setException(Throwable t) {
        // 如果state是new 把state设置成 COMPLETING 
        if (U.compareAndSwapInt(this, STATE, NEW, COMPLETING)) {
            outcome = t;
            // 将任务设置成EXCEPTIONAL
            U.putOrderedInt(this, STATE, EXCEPTIONAL); // final state
            finishCompletion();
        }
    }

如果现在的状态是NEW 就把状态设置成COMPLETING 然后设置成EXCEPTIONAL。这个执行流程导致的状态变化就是

NEW->COMPLETING->EXCEPTIONAL

执行步骤是首先执行 run() 并且Task抛出异常而且在这其间没有调用cancel()。

上文所分析的场景只是run()方法被调用了而在run()方法执行的过程中调用cancel()并没有分析，两个方法有时间交集的情况我们稍后分析。

FutureTask cancel()

现在我们分析下cancel()方法先被调用的情况

   
       public boolean cancel(boolean mayInterruptIfRunning) {
        // mayInterruptIfRunning 是否中断running
        // 这个判断逻辑等价于：
        //  if(state!=new || !UNSAFE.compareAndSwapInt(this, stateOffset, NEW, mayInterruptIfRunning ? INTERRUPTING : CANCELLED)) 
        // 1、如果state不是new 那么就退出方法，这时的任务是已经完成了 或是被取消了 或是被中断了 
        // 2、如果是state是new 就设置state 为中断状态 或是取消状态 
        if (!(state == NEW &&
              U.compareAndSwapInt(this, STATE, NEW,
                  mayInterruptIfRunning ? INTERRUPTING : CANCELLED)))
            return false;
        try {    // in case call to interrupt throws exception
            // 如果是可中断 那么就调用系统中断方法 然后把状态设置成INTERRUPTED  
            if (mayInterruptIfRunning) {
                try {
                    Thread t = runner;
                    if (t != null)
                        t.interrupt();
                } finally { // final state
                    U.putOrderedInt(this, STATE, INTERRUPTED);
                }
            }
        } finally {
            finishCompletion();
        }
        return true;
    }

这个方法很简单：

1、.如果是cancel(false) 那么Task的状态变化就是

NEW->=CANCELLED

2、如果是cancel(true)那么Task的状态化就是

NEW->INTERRUPTING ->INTERRUPTED

至此Task的四种状态变化我们都看到了，不过这都是在两个方法都是单独执行的情况。

我们在分析下两个方法交叉执行的情况( run()->cancel() )：

1、如果Task已经执行(run)然后再调用cancel():

A、调用cancel(false)情况

如果Task已经在执行而callable.call()没有返回或是 call()已经返回但是state状态还没有改变，那么任务调用cancel(false) 不会对任务的执行造成影响只会影响task的状态。

如果callable.call()已经返回并且状态已经变成COMPLETING或是 COMPLED 那么对任务执行和任务状态都没有影响。

B、调用cancel(true)

如果任务已经在执行而callable.call()没有返回，会把state设置成 INTERRUPTING然后调用执行线程的中断请求然后把状态设置成INTERRUPTED,这里如果 callable.call()方法可以响应中断可能对任务执行产生影响，如果方法不会响应中断不会对任务运行产生影响。影响任务的状态。

如果任务已经在执行并且 call()已经返回但是state状态还没有改变不会对任务的执行造成影响只会影响任务的状态。

2、调用cancel()后在执行任务 ( cancel() -> run() )

先调用cancel()无论是那种调用方式都会引起state状态的变化。在run()方法执行的时候发现state已经不是new了就会放弃任务的执行。

任务结果回调方法 done()

不管是run，还是cancel，最后都会调用finishCompletion()方法。

   
       private void finishCompletion() {
        // assert state > COMPLETING;
        for (WaitNode q; (q = waiters) != null;) {
            if (U.compareAndSwapObject(this, WAITERS, 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;
            }
        }
        // 子类覆写此方法，在计算结果结束后会回调此方法，获取结果的方法：get()
        done();
        callable = null;        // to reduce footprint
    }

获取结果的方法 get()

   
       public V get() throws InterruptedException, ExecutionException {
        int s = state;
        // 如果没有计算完成，则等待
        if (s <= COMPLETING)
            s = awaitDone(false, 0L);
        return report(s);
    }

    
        private V report(int s) throws ExecutionException {
        // 获取到结果
        Object x = outcome;
        // 如果是正常，则返回结果
        if (s == NORMAL)
            return (V)x;
        // 如果是异常，则抛出异常 CancellationException
        if (s >= CANCELLED)
            throw new CancellationException();
        throw new ExecutionException((Throwable)x);
    }