并发编程:你真的了解FutureTask吗?

FutureTask是什么

public interface Runnable {
    public abstract void run();
}

Student implements Runnable

Thread xiaoming = new Thread(new Student());

xiaoming.start();

我们知道Runnable是一个接口,它用来承载的是具体的任务,交给Thread执行。

创新互联建站主要从事网站制作、成都网站设计、网页设计、企业做网站、公司建网站等业务。立足成都服务澄江,十年网站建设经验,价格优惠、服务专业,欢迎来电咨询建站服务:028-86922220

有这样一个场景:主线程执行一个任务(理解为调用一个方法)需要获取这个任务的返回值,然后再去执行另一个任务获取返回值,最后将两个返回值做其他处理,一般情况下耗时为两个任务的耗时和,如果想提高性能,可以用异步的方式,可以将任务一包装为Runnable,交给子线程执行,主线程执行第二个任务,这样就节省了一部分耗时,但是Runnable不支持返回值,所以行不通,而FutureTask就是解决这个问题的。

FutureTask的类图如下:

看图可以知道两个事:

  • 实现了Runnable接口,所以FutureTask也是一个可以承载任务的任务类。
  • 实现了Future接口,Future接口提供了任务操作和获取返回值等方法,利用Future接口可以获取任务执行状态,取消任务,获取任务返回值等。

所以说FutureTask就是一个实现了一套获取返回值机制的任务体,请注意它依然是任务体,自身不能执行任务,依然需要借助Thread执行。

FutureTask应用例子

Callable callableTask = () -> {
    // 一些耗时的计算
    return 42;
};

FutureTask futureTask = new FutureTask<>(callableTask);
Thread thread = new Thread(futureTask);
thread.start();

try {
    Integer result = futureTask.get(); // 阻塞直到任务完成并返回结果
    System.out.println("任务结果:" + result);
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
}

上面就是使用案例,看起来写法比较复杂,其实一旦理解就不复杂了,首先我们上面说了FutureTask实现了Runnable,所以它是任务体,任务体需要依赖Thread执行,所以这里FutureTask和Runnable的写法一样都是作为Thread的入参。

代码中可以看到还有一个Callable类,这个其实也是任务体,它的源码如下:

public interface Callable {
    V call() throws Exception;
}

它是一个有返回值的任务体,但是它和Runnable不同,Runnable是和Thread绑定的官方任务体,而Callable只是为达到实现获取任务返回值而衍生出来的一个任务体,它主要作为FutureTask类中的一个成员属性,充当真正被执行的任务体。

FutureTask源码分析

先看下FutureTask主要的属性和构造方法:

public class FutureTask implements RunnableFuture {
    private volatile int state;
    //等待执行状态 初始状态
    private static final int NEW          = 0;
    //执行完毕状态,但是结果还没有填充到outcome
    private static final int COMPLETING   = 1;
    //返回值填充outcome 正常结束任务状态
    private static final int NORMAL       = 2;
    //因异常而结束
    private static final int EXCEPTIONAL  = 3;
    //任务还未执行之前就调用了cancel(true)方法
    private static final int CANCELLED    = 4;
    //中断的中间状态
    private static final int INTERRUPTING = 5;
    //中断的状态
    private static final int INTERRUPTED  = 6;

    private Callable callable;
    private Object outcome; 
    private volatile Thread runner;
    private volatile WaitNode waiters;
    
    static final class WaitNode {
        volatile Thread thread;
        volatile WaitNode next;
        WaitNode() { 
        thread = Thread.currentThread(); 
        }
    }
    
    protected void done() { }
    
     public FutureTask(Callable callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;       
    }

    public FutureTask(Runnable runnable, V result) {
        this.callable = Executors.callable(runnable, result);
        this.state = NEW;       
    }
  • state是状态,没到一个阶段都是不同的状态。
  • outcome是存放返回值的,当任务执行完返回的值会赋值给outcome
  • callable是真正的任务体,run方法在运行的时候实际上是运行callable对象的call方法。
  • waiters是线程阻塞等待结果的时候存放的队列,它的类型是WaitNode,WaitNode里面有一个next属性,可见它是一个单向链表结构。
  • runner是当前正在执行任务的线程
  • done方法在FutureTask里面没有具体实现,它是任务处理完的一个后置方法,是留给子类用的。
  • 构造方法一是接收一个Callable对象赋值给成员变量callable。- 构造方法二是接收一个Runnable对象和一个result值,同样是赋值给callable变量。

构造方法一很容易理解,构造方法二则是接收一个Runnable任务体,但是Runnable没有返回值,所以再接收一个result值作为默认的返回值,也就是无论任务体的任务执行的结果是什么,都以result值作为固定的返回值。

public static  Callable callable(Runnable task, T result) {
        if (task == null)
            throw new NullPointerException();
        return new RunnableAdapter(task, result);
    }

 static final class RunnableAdapter implements Callable {
        final Runnable task;
        final T result;
        RunnableAdapter(Runnable task, T result) {
            this.task = task;
            this.result = result;
        }
        public T call() {
            task.run();
            return result;
        }
    }

构造方法二中调用了Executors.callable()方法,这个方法就是将Runnable和result值封装为RunnableAdapter对象,RunnableAdapter实现了Callable,所以它也是一个Callable对象,所以可以赋值给成员变量callable.

接下来按照应用案例中的步骤跟一下源码,构造方法我们看了,接下来就是启动线程,启动线程就会调用任务体的run方法,我们从run方法开始跟进源码。

run方法源码分析

 public void run() {
        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 {
                    result = c.call();
                    ran = true;
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                    setException(ex);
                }
                if (ran)
                    set(result);
            }
        } finally {
            int s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }
  1. 判断状态,只有当前状态为待执行状态,并且能利用cas将当前线程成功赋值给runner,进入下一步。
  2. 如果成员变量callable不为空,执行任务体callable的call方法并得到返回值result。
  3. 调用set(result)方法。
 protected void set(V v) {
        if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
            outcome = v;
            UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
            finishCompletion();
        }
    }
  1. 将状态由NEW(待执行状态)改为COMPLETING(执行完成状态)。
  2. 将返回值result赋值给成员变量outcome。
  3. 将状态由改为COMPLETING(执行完成状态)NORMAL(返回值填充完毕状态)
  4. 调用finishCompletion()
  private void finishCompletion() {
        for (WaitNode q; (q = waiters) != null;) {
            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; 
                    q = next;
                }
                break;
            }
        }
        done();
        callable = null;       
    }
  1. 这个方法其实就是唤醒正在等待结果的线程,可能有多个线程在等待任务返回值,等待的线程都会被封装为一个WaitNode节点,多个节点以单向链表结构连接在一起,这个方法是从链表的头节点一个一个唤醒。

将所有的等待线程唤醒后,最后执行done方法,done方法在FutureTask没有被实现,所以也就相当于什么都不做,那么done存在的意义是什么呢?它存在的意义在于在任务处理的完毕后线程结束前做一些事情,是留给子类扩展用的。

再看futureTask.get()的源码分析

当前线程是等待任务结果的线程不同于上面执行任务的线程:

 public V get() throws InterruptedException, ExecutionException {
        int s = state;
        if (s <= COMPLETING)
            s = awaitDone(false, 0L);
        return report(s);
    }
  1. 如果此时状态是返回值填充完毕状态,那就进入report方法直接返回值即可,如果此时状态不是返回值填充完毕状态,就要进入awaitDone方法进行阻塞等待操作。awaitDone方法是支持阻塞指定时长的。如果没有传入阻塞时长就是永久阻塞。
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);
        }
    }
  1. 先计算等待时长,结果要么是需要等待一定时长,要么是永久等待。
  2. 进入循环进行一些力的判断处理。
  3. 判断中断,如果是被中断直接出队并抛异常(外面可以通过捕获异常让下城跳出循环)。可见阻塞等待是可以被中断的。
  4. 如果此时状态是大于等于返回值填充完毕状态直接返回此状态。
  5. 如果此时状态为执行完毕状态,但是还没有到达返回值填充完毕状态,那就让出cpu稍微等待一下,因为这两个状态的间隔很短。
  6. 如果上面的判断都不满足,那就为当前线程绑定WaitNode节点。
  7. 如果绑定的WaitNode节点还没有入队,那就通过cas方式入队,就是替换头节点,也就是后进来的为头节点。
  8. 如果指定了阻塞时间,此时要判断是否超时,如果超时就直接返回状态,如果没有超时,计算出所剩的时间,然后利用LockSupport.parkNanos阻塞。
  9. 如果上面都不满足就利用LockSupport.park进入永久阻塞。

上面就是FutureTask主要的源码分析,其原理比较简单,如果是run方法中提供返回值的支持,还有一个方法runAndReset,它提供了任务循环执行的支持。

protected boolean runAndReset() {
        if (state != NEW ||
            !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                         null, Thread.currentThread()))
            return false;
        boolean ran = false;
        int s = state;
        try {
            Callable c = callable;
            if (c != null && s == NEW) {
                try {
                    c.call(); // don't set result
                    ran = true;
                } catch (Throwable ex) {
                    setException(ex);
                }
            }
        } finally {
            s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
        return ran && s == NEW;
    }

这个代码很简单,如果状态为待执行,就会执行任务,不关心返回值,任务执行完不会更新状态,使得状态一直处于待执行状态,如果runAndReset方法被再次调用依然会再一次执行任务。ScheduledThreadPoolExecutor就利用了这个方法实现定时任务处理。

其他方法支持

上面说了FutureTask实现了Future接口,Future接口提供了对任务处理的能力

//获取任务结果 如果任务没有处理完就阻塞等待timeout时间
V get(long timeout, TimeUnit unit);
//获取任务结果 如果任务没有处理完就永久阻塞等待
V get(); 
//任务执行完毕后执行的方法,用于子类扩展用
boolean isDone();
//任务是否被取消 true为已取消
boolean isCancelled();
//取消任务
boolean cancel(boolean mayInterruptIfRunning);

cancel为取消任务,它有一个boolean类型的参数,true表示需要中断线程并且将状态改为INTERRUPTING,false表示只改状态为CANCELLED。

cancel方法的逻辑如下:

  1. 只有处于待执行状态的任务才会被取消
  2. 传参为false,状态由NEW改为CANCELLED
  3. 传参为true,状态由NEW改为INTERRUPTING
  4. 同时如果传参是true,则调用负责执行任务的那个线程的interrupt方法进行中断操作,最后将状态由INTERRUPTING改为INTERRUPTED
  5. 唤醒所有正在等待任务结果的线程。
  6. 最后执行done方法。

网站栏目:并发编程:你真的了解FutureTask吗?
文章地址:http://www.shufengxianlan.com/qtweb/news2/406652.html

网站建设、网络推广公司-创新互联,是专注品牌与效果的网站制作,网络营销seo公司;服务项目有等

广告

声明:本网站发布的内容(图片、视频和文字)以用户投稿、用户转载内容为主,如果涉及侵权请尽快告知,我们将会在第一时间删除。文章观点不代表本网站立场,如需处理请联系客服。电话:028-86922220;邮箱:631063699@qq.com。内容未经允许不得转载,或转载时需注明来源: 创新互联