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

2021-08-20 14:35:32

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()方法等待的线程
上一篇：验证jquery.validate.js


下一篇：Android＋Eclipse＋Java：在“正在启动 CrazySnake”期间发生了内部错误， java.lang.NullPointerException