java.util.concurrent解析——FutureTask源码解析-阿里云开发者社区

开发者社区> 李牙刷儿> 正文

java.util.concurrent解析——FutureTask源码解析

简介: 和Java异步打交道就不能回避掉`Runnable`,`Callable`,`Future`,`FutureTask`等类,首先来介绍下这几个类的区别
+关注继续查看

1. Runnable、Callable、Future、FutureTask的区别与联系

和Java异步打交道就不能回避掉Runnable,Callable,Future,FutureTask等类,首先来介绍下这几个类的区别。

1.1 Runnable

Runnable接口是我们最熟悉的,它只有一个run函数。然后使用某个线程去执行该runnable即可实现多线程,Thread类在调用start()函数后就是执行的是Runnable的run()函数。Runnable最大的缺点在于run函数没有返回值。

1.2 Callable

Callable接口和Runnable接口类似,它有一个call函数。使用某个线程执行Callable接口实质就是执行其call函数。call方法和run方法最大的区别就是call方法有返回值:

public interface Callable<V> {  
    /** 
     * Computes a result, or throws an exception if unable to do so. 
     * 
     * @return computed result 
     * @throws Exception if unable to compute a result 
     */  
    V call() throws Exception;  
} 

1.3 Future

Future就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果、设置结果操作。get方法会阻塞,直到任务返回结果(Future简介)。

1.4 FutureTask

Future只是一个接口,在实际使用过程中,诸如ThreadPoolExecutor返回的都是一个FutureTask实例。

public class FutureTask<V> implements RunnableFuture<V>  

public interface RunnableFuture<V> extends Runnable, Future<V> {  
    /** 
     * Sets this Future to the result of its computation 
     * unless it has been cancelled. 
     */  
    void run();  
}  

可以看到,FutureTask是一个RunnableFuture,而RunnableFuture实现了Runnbale又实现了Futrue这两个接口。

2 FutureTask的构造过程

事实上,通过ExecutorService接口的相关submit方法,实际上都是提交的Callable或者Runnable,包装成一个FutureTask对象。

public abstract class AbstractExecutorService implements ExecutorService {
  ...
  //将Runable包装成FutureTask之后,再调用execute方法
  public Future<?> submit(Runnable task) {
      if (task == null) throw new NullPointerException();
      RunnableFuture<Void> ftask = newTaskFor(task, null);
      execute(ftask);
      return ftask;
  }
  
  //调用newTaskFor方法,利用Callable构造一个FutureTask对象
  protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
      return new FutureTask<T>(callable);
  }
}

可以看到AbstractExecutorService的submit方法调用后返回的就是一个FutureTask对象,接下来看下FutureTask的构造方法:

//接受Callable对象作为参数
public FutureTask(Callable<V> callable) {
    if (callable == null)
        throw new NullPointerException();
    this.callable = callable;
    this.state = NEW;    
}
//接受Runnable对象作为参数
public FutureTask(Runnable runnable, V result) {
    this.callable = Executors.callable(runnable, result);//将Runnable转为Callable对象
    this.state = NEW;     
}

//callable方法,将Runnable转为一个Callable对象,包装设计模式
public static <T> Callable<T> callable(Runnable task, T result) {
    if (task == null)
        throw new NullPointerException();
    return new RunnableAdapter<T>(task, result);
}
 
//RunnableAdapter是Executors的一个内部类,实现了Callable接口
static final class RunnableAdapter<T> implements Callable<T> {
    final Runnable task;
    final T result;
    RunnableAdapter(Runnable task, T result) {
        this.task = task;
        this.result = result;
    }
    public T call() {
        task.run();
        return result;
    }
}

可以看到,构造FutureTask时,无论传入的是Runnable还是Callable,最终都实现了Callable接口。

3 FutureTask主要成员

接下来看下FutureTask类的主要成员变量:

public class FutureTask<V> implements RunnableFuture<V> {
     /*
     * FutureTask中定义了一个state变量,用于记录任务执行的相关状态 ,状态的变化过程如下
     * NEW -> COMPLETING -> NORMAL
     * NEW -> COMPLETING -> EXCEPTIONAL
     * NEW -> CANCELLED
     * NEW -> INTERRUPTING -> INTERRUPTED
     */
    private volatile int state;
    //主流程状态
    private static final int NEW = 0; //当FutureTask实例刚刚创建到callbale的call方法执行完成前,处于此状态
    private static final int COMPLETING  = 1; //callable的call方法执行完成或出现异常时,首先进行此状态
    private static final int NORMAL    = 2;//callable的call方法正常结束时,进入此状态,将outcom设置为正常结果
    private static final int EXCEPTIONAL = 3;//callable的call方法异常结束时,进入此状态,将outcome设置为抛出的异常
    //取消任务执行时可能处于的状态
    private static final int CANCELLED= 4;// FutureTask任务尚未执行,即还在任务队列的时候,调用了cancel方法,进入此状态
    private static final int INTERRUPTING = 5;// FutureTask的run方法已经在执行,收到中断信号,进入此状态
    private static final int INTERRUPTED  = 6;// 任务成功中断后,进入此状态
    
    private Callable<V> callable;//需要执行的任务,提示:如果提交的是Runnable对象,会先转换为Callable对象,这是构造方法参数
    private Object outcome; //任务运行的结果
    private volatile Thread runner;//执行此任务的线程
  
    //等待该FutureTask的线程链表,对于同一个FutureTask,如果多个线程调用了get方法,对应的线程都会加入到waiters链表中,同时当FutureTask执行完成后,也会告知所有waiters中的线程
    private volatile WaitNode waiters;
    ......
}

FutureTask的成员变量并不复杂,主要记录以下几部分信息:

  • 状态
  • 任务(callable)
  • 结果(outcome)
  • 等待线程(waiters)

4 FutureTask的执行过程

4.1 run

接下来开始看一个FutureTask的执行过程,FutureTask执行任务的方法当然还是run方法:

public void run() {
    //保证callable任务只被运行一次
    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 {
                //执行任务
                result = c.call();
                ran = true;
            } catch (Throwable ex) {
                result = null;
                ran = false;
                setException(ex);
            }
            if (ran)
                set(result);
        }
    } finally {
        runner = null;
        int s = state;
        //判断该任务是否正在响应中断,如果中断没有完成,则等待中断操作完成
        if (s >= INTERRUPTING)
            handlePossibleCancellationInterrupt(s);
    }
}
  • 如果状态不为new或者运行线程runner失败,说明当前任务已经被其他线程启动或者已经被执行过,直接返回false
  • 调用call方法执行核心任务逻辑。如果调用成功则执行set(result)方法,将state状态设置成NORMAL。如果调用失败抛出异常则执行setException(ex)方法,将state状态设置成EXCEPTIONAL,唤醒所有在get()方法上等待的线程
  • 如果当前状态为INTERRUPTING(步骤2已CAS失败),则一直调用Thread.yield()直至状态不为INTERRUPTING

4.2 set、setException方法

protected void set(V v) {
    if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
        outcome = v;
        UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
        finishCompletion();
    }
}

protected void setException(Throwable t) {
    if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
        outcome = t;
        UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state
        finishCompletion();
    }
}

两个方法的逻辑基本一致,先通过CAS操作将状态从NEW置为COMPLETING,然后再将最终状态分别置为NORMAL或者EXCEPTIONAL,最后再调用finishCompletion方法。

4.3 finishCompletion

private void finishCompletion() {
    for (WaitNode q; (q = waiters) != null;) {
        //通过CAS把栈顶的元素置为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; // unlink to help gc
                q = next;
            }
            break;
        }
    }
    done();
    callable = null;        // to reduce footprint
}

finishCompletion的逻辑也比较简单:

  • 遍历waiters链表,取出每一个节点:每个节点都代表一个正在等待该FutureTask结果(即调用过get方法)的线程
  • 通过 LockSupport.unpark(t)唤醒每一个节点,通知每个线程,该任务执行完成

4.4 get

在finishCompletion方法中,FutureTask会通知waiters链表中的每一个等待线程,那么这些线程是怎么被加入到waiters链表中的呢?上文已经讲过,当在一个线程中调用了get方法,该线程就会被加入到waiters链表中。所以接下来看下get方法:

public V get(long timeout, TimeUnit unit)
    throws InterruptedException, ExecutionException, TimeoutException {
    if (unit == null)
        throw new NullPointerException();
    int s = state;
    if (s <= COMPLETING &&
        (s = awaitDone(true, unit.toNanos(timeout))) <= COMPLETING)
        throw new TimeoutException();
    return report(s);
}

get方法很简答,主要就是调用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 (;;) {
        //如果该线程执行interrupt()方法,则从队列中移除该节点,并抛出异常
        if (Thread.interrupted()) {
            removeWaiter(q);
            throw new InterruptedException();
        }
        int s = state;
        //如果state状态大于COMPLETING 则说明任务执行完成,或取消
        if (s > COMPLETING) {
            if (q != null)
                q.thread = null;
            return s;
        }
        //如果state=COMPLETING,则使用yield,因为此状态的时间特别短,通过yield比挂起响应更快。
        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);
        //如果需要阻塞指定时间,则使用LockSupport.parkNanos阻塞指定时间
        //如果到指定时间还没执行完,则从队列中移除该节点,并返回当前状态
        else if (timed) {
            nanos = deadline - System.nanoTime();
            if (nanos <= 0L) {
                removeWaiter(q);
                return state;
                }
                LockSupport.parkNanos(this, nanos);
            }
            //阻塞当前线程
            else
                LockSupport.park(this);
        }
}

整个方法的大致逻辑主要分为以下几步:

  • 如果当前状态值大于COMPLETING,说明已经执行完成或者取消,直接返回
  • 如果state=COMPLETING,则使用yield,因为此状态的时间特别短,通过yield比挂起响应更快
  • 如果当前线程是首次进入循环,为当前线程创建wait节点加入到waiters链表中
  • 根据是否定时将当前线程挂起(LockSupport.parkNanos LockSupport.park)来阻塞当前线程,直到超时或者线程被finishCompletion方法唤醒
  • 当线程挂起超时或者被唤醒后,重新循环执行上述逻辑

get方法是FutureTask中的关键方法,了解了get方法逻辑也就了解为什么当调用get方法时线程会被阻塞直到任务运行完成。

4.5 cancel

cancel方法用于结束当前任务:

public boolean cancel(boolean mayInterruptIfRunning) {
    if (!(state == NEW &&
          UNSAFE.compareAndSwapInt(this, stateOffset, NEW,
              mayInterruptIfRunning ? INTERRUPTING : CANCELLED)))
        return false;
    try {    // in case call to interrupt throws exception
        if (mayInterruptIfRunning) {
            try {
                Thread t = runner;
                if (t != null)
                    t.interrupt();
            } finally { // final state
                UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED);
            }
        }
    } finally {
        finishCompletion();
    }
    return true;
}
  • 根据mayInterruptIfRunning是否为true,CAS设置状态为INTERRUPTING或CANCELLED,设置成功,继续第二步,否则返回false
  • 如果mayInterruptIfRunning为true,调用runner.interupt(),设置状态为INTERRUPTED
  • 唤醒所有在get()方法等待的线程

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
【Java入门提高篇】Day21 Java容器类详解(四)ArrayList源码分析
 今天要介绍的是List接口中最常用的实现类——ArrayList,本篇的源码分析基于JDK8,如果有不一致的地方,可先切换到JDK8后再进行操作。   本篇的内容主要包括这几块:   1.
1050 0
java B2B2C Springboot多租户电子商城系统-Eureka源码解析
Eureka的限流算法类RateLimiter是基于令牌桶算法来实现的,下面看一看令牌桶算法的原理: 需要JAVA Spring Cloud大型企业分布式微服务云构建的B2B2C电子商务平台源码 一零三八七七四六二六 对于很多应用场景来说,除了要求能够限制数据的平均传输速率外,还要求允许某种程度的突发传输。
1108 0
【Java入门提高篇】Day23 Java容器类详解(六)HashMap源码分析(中)
  上一篇中对HashMap中的基本内容做了详细的介绍,解析了其中的get和put方法,想必大家对于HashMap也有了更好的认识,本篇将从了算法的角度,来分析HashMap中的那些函数。 HashCode   先来说说HashMap中HashCode的算法,在上一篇里,我们看到了HashMap中的...
1177 0
阿里云服务器端口号设置
阿里云服务器初级使用者可能面临的问题之一. 使用tomcat或者其他服务器软件设置端口号后,比如 一些不是默认的, mysql的 3306, mssql的1433,有时候打不开网页, 原因是没有在ecs安全组去设置这个端口号. 解决: 点击ecs下网络和安全下的安全组 在弹出的安全组中,如果没有就新建安全组,然后点击配置规则 最后如上图点击添加...或快速创建.   have fun!  将编程看作是一门艺术,而不单单是个技术。
4550 0
Core Image 框架详细解析
Core Image框架详细解析(一) —— 基本概览Core Image框架详细解析(二) —— Core Image滤波器参考Core Image框架详细解析(三) —— 关于Core ImageCore Image框架详细解析(四) —— Pro...
770 0
ArrayList源码解析(基于Java8)
首先:执行List list1 = new ArrayList(); 在堆内存开辟了一块空间,既然是new出来的,那我们直接从构造函数入手 Object[]数组,也就是说该数组可以放任何对象(所有对象都继承自父类Object) 继续,执行list1.
889 0
零基础学Java系列二:23节视频课+源码解析简单Java类 | 开发者进阶站
刚入门的你是不是想要“窥探”更多Java的秘密,那就快来吧,用范例带你轻松学Java!
735 0
阿里云服务器如何登录?阿里云服务器的三种登录方法
购买阿里云ECS云服务器后如何登录?场景不同,阿里云优惠总结大概有三种登录方式: 登录到ECS云服务器控制台 在ECS云服务器控制台用户可以更改密码、更换系.
5761 0
+关注
李牙刷儿
Android开发者&amp;前端菜鸟,专注于跨平台、热修复领域
87
文章
0
问答
文章排行榜
最热
最新
相关电子书
更多
文娱运维技术
立即下载
《SaaS模式云原生数据仓库应用场景实践》
立即下载
《看见新力量:二》电子书
立即下载