并发系列--Future和Callable

一、Runnable的缺陷

---

在多线程开发中，一般都会使用Runnable来处理异步任务，但是它有一定的缺陷
1、不能返回一个返回值
2、也不能抛出checked Exception

接着就可以引入下面主题，Callable和Future，它在Android源码中很多地方使用到了，比如AsyncTask中，学会了Callable和Future，就可以更方便看源码。

二、有返回值Callable接口

---

它是一个接口，约定了线程要做的事情，作用：

1、类似于Runnable，被其它线程执行的任务
2、实现call方法
3、有返回值
4、可以抛出异常

Callable一般和Future一起使用，不会单独使用

三、Future类

---

Future的作用

---

方法的计算可能很耗时，计算的过程中，没有必要在原地等返回，子线程执行过程中可以取做其它事情，执行完成，Future可以获取计算的结果。

Callable和Future的关系

---

我们可以用Future.get来获取Callable接口返回的执行结果，还可以通过Future.isDone()来判断任务是否已经执行完了，以及取消这个任务，限时获取任务的结果等

在call()方法未执行完毕之前，调用get()的线程（假定此时是主线程）会被阻塞，直到call()方法返回了结果后，此时future.get()才会得到该结果，然后主线程才会切换到runnable状态

所以Future是一个存储器，它存储了call()这个任务的结果，而这个任务的执行时间是无法提前确定的，因为这完全取决于call()方法执行的情况

四、Future的主要方法：一共5个

---

get方法

---

get方法的行为取决于Callable任务的状态，只有以下5种情况

1、任务正常完成:get方法会立刻返回
2、任务尚未完成（任务还没开始或进行中）：get将会阻塞并直到任务完成
3、任务执行过程中Execption：get方法会抛出ExecutionException:这里抛出异常，是call()执行时产生的那个异常，看到这个异常类型时java.util,concurrent.ExecutionException。不论call()执行时抛出的异常类型是什么，最后get方法抛出的异常类型都是ExecutionException。
4、任务被取消：get方法会抛出CancellationException
5、任务超时：get方法有一个重载方法，是传入一个延迟时间的，如果时间到了还没有获得结果，get方法就会抛出TimeoutException

get(long timeout, TimeUnit unit)：有超时的获取

---

超时的需求很常见

用get(long timeout, TimeUnit unit)方法时，如果call()在规定时间内完成任务，那么就会正常获取到返回值；而如果再指定时间内没有计算出结果，那么就会抛出TimeoutException

超时不获取，任务需取消

cancel()方法

---

取消任务的执行

isDone()方法

---

判断线程是否执行完毕

isCancelled()方法

---

判断是否被取消

五、Future用法

---

几种常用的用法

用法一 ：线程池的submit方法返回Future对象

---

首先，我们要给线程池提交我们的任务，提交时线程池就会立刻返回给我们一个空的Future容器。当线程的任务一旦执行完毕，也就是当我们可以获取结果的时候，线程池便会把该结果填入到之前给我们的那个Future中去（而不是创建一个新的Future），我们此时便可以从该Future中获得任务执行的结果。

//演示一个Future的使用方法
@Test
public void test02(){
    ExecutorService service = Executors.newFixedThreadPool(10);
    Future<Integer> future = service.submit(new CallableTask());
    try {
        System.out.println(future.get());
    } catch (ExecutionException e) {
        e.printStackTrace();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    service.shutdown();
}
class CallableTask implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {

        Thread.sleep(3000);

        return new Random().nextInt();
    }
}

1、Callable定义我们需要做的事情，是可以有返回值的
2、传入Callable任务，可以获取Future返回值
3、通过Future.get可以获取子线程执行结果

用法二：多个任务，用Future数组来获取结果

---

//演示批量提交任务时，用List来批量获取结果
@Test
public void test03() throws InterruptedException {
    ExecutorService service = Executors.newFixedThreadPool(20);
    ArrayList<Future> futures = new ArrayList<>();
    for (int i = 0; i < 20; i++) {
        Future<Integer> future = service.submit(new CallableTask());
        futures.add(future);
    }
    Thread.sleep(5000);
    for (int i = 0; i < 20; i++) {
        Future<Integer> future = futures.get(i);
        try {
            Integer integer = future.get();
            System.out.println(integer);
        } catch (ExecutionException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class CallableTask implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {

        Thread.sleep(3000);

        return new Random().nextInt();
    }
}

用法三：任务执行过程中抛出Exception和isDone展示

---

//演示get方法过程中抛出异常，for循环为了演示抛出Exception的时机：并不是说一产生异常就抛出，直到我们get执行时，才会抛出。
@Test
public void test04(){
    ExecutorService service = Executors.newFixedThreadPool(20);
    Future<Integer> future = service.submit(new CallableTask04());
    try {
        for (int i = 0; i < 5; i++) {
            System.out.println(i);
            Thread.sleep(500);
        }
        System.out.println(future.isDone());
        future.get();
    } catch (ExecutionException e) {
        e.printStackTrace();
        System.out.println("ExecutionException异常");
    } catch (InterruptedException e) {
        e.printStackTrace();
        System.out.println("InterruptedException异常");
    }
}

class CallableTask04 implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        throw new IllegalArgumentException("Callable抛出异常");
    }
}

执行get才会抛出异常

用法四：默认广告的超时和取消

---

private final Ad DEFAULT_AD = new Ad("无网络时候的默认广告");
private final ExecutorService service = Executors.newFixedThreadPool(2);

class FetchAdTask implements Callable<Ad>{

    @Override
    public Ad call() throws Exception {
        try{
            Thread.sleep(3000);
        }catch (InterruptedException e){
            System.out.println("sleep期间被中断了");
            return new Ad("被中断时候的默认广告");
        }
        return new Ad("淘宝广告");
    }

}

public void printAd(){
    Future<Ad> f = service.submit(new FetchAdTask());
    Ad ad;

    try {
        ad = f.get(2000, TimeUnit.MILLISECONDS);
    } catch (ExecutionException e) {
        e.printStackTrace();
        ad = new Ad("异常时候的默认广告");
    } catch (InterruptedException e) {
        e.printStackTrace();
        ad = new Ad("中断时候的默认广告");
    } catch (TimeoutException e){
        //            e.printStackTrace();
        ad = new Ad("异常时候的默认广告");

        System.out.println("超时了，未获取到广告");

        //cancel true 中断 false不会中断
        boolean cancel = f.cancel(true);
        System.out.println("cancel的结果" + cancel);
    }

    service.shutdown();
    System.out.println(ad);
}

//演示get的超时方法，需要注意超时后处理，调用future.cancel()。演示cancel传入true和false的区别，代表是否中断正在执行的任务。
@Test
public void test05(){

    printAd();

}

六、cancel:取消任务的执行

---

1、如果这个任务还没有开始执行，那么这种情况最简单，任务会被正常的取消，未来也不会被执行，方法返回true

2、如果任务已完成，或者已取消，那么cancel()方法会执行失败，方法返回false

3、如果这个任务已经开始执行了，那个这个取消方法将不会直接取消该任务，而是会根据我们填的参数mayInterruptIfRunning做判断；

Future.cancel(true)适用于：

1、任务能够处理interrupt

Future.cancel(false)仅用于避免启动尚未启动的任务，适用于：

1、未能处理interrupt的任务

2、不清除任务是否支持取消

3、需要等待已经开始的任务执行完成

七、用FutureTask来获取结果

---

FutureTask是一种包装器，可以把Callable转化成Future和Runnable，它同时实现二者的接口

用Callable实例当作参数，生成FutureTask的对象，然后把这个对象当作一个Runnable对象，用线程池或另起线程区执行这个Runnable对象，最后通过FutureTask获取刚才执行的结果。

/**
 * 描述：     演示FutureTask的用法
 */
public class FutureTaskDemo {

    public static void main(String[] args) {
        Task task = new Task();
        FutureTask<Integer> integerFutureTask = new FutureTask<>(task);
//        new Thread(integerFutureTask).start();
        ExecutorService service = Executors.newCachedThreadPool();
        service.submit(integerFutureTask);

        try {
            System.out.println("task运行结果："+integerFutureTask.get());

        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

class Task implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        System.out.println("子线程正在计算");
        Thread.sleep(3000);
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            sum += i;
        }
        return sum;
    }
}

八、Future的使用注意点

---

1、当for循环获取future的结果时，容易发生一部分线程很慢的情况，get方法调用时应使用timeout限制

2、Future的生命周期不能后退
生命周期只能前进，不能后退。就和线程池的生命周期一样，一旦完全完成了任务，它就永远停在了“已完成”的状态，不能重来。

使用完之后，开始分析源码

九、Callable实现

---

接口定义：

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

返回值是一个泛型，可以定义成为任何类型，并且可以看到是可以抛出异常的，在向线程池提交任务时，可以提交Runnable和Callable两种任务类型，

public Future<?> submit(Runnable task) {
    if (task == null) throw new NullPointerException();
    RunnableFuture<Void> ftask = newTaskFor(task, null);
    execute(ftask);
    return ftask;
}

public <T> Future<T> submit(Callable<T> task) {
    if (task == null) throw new NullPointerException();
    RunnableFuture<T> ftask = newTaskFor(task);
    execute(ftask);
    return ftask;
}

这两种任务都会转化为Callable

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

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

RunnableAdapter是Callable一个实现，然后会包装到FutureTask中，线程运行的具体任务是通过它， FutureTask 实现了 RunnableFuture 接口

public class FutureTask<V> implements RunnableFuture<V> {

}

而 RunnableFuture 又实现了 Runnable, Future 两个接口。

十、Future实现

---

Callable 是可以返回子线程执行结果的，在获取结果的时候，就需要用到 Future接口

Future接口注释写了这些：

1、定义了异步计算的接口，提供了计算是否完成的 check、等待完成和取回等多种方法；
2、如果想得到结果可以使用 get 方法，此方法(无参方法)会一直阻塞到异步任务计算完成；
3、取消可以使用 cancel 方法，但一旦任务计算完成，就无法被取消了。

Future接口定义了这些方法：

public interface Future<V> {

// 如果任务已经成功了，或已经取消了，是无法再取消的，会直接返回取消成功(true)
// 如果任务还没有开始进行时，发起取消，是可以取消成功的
// 如果取消时，任务已经在运行了，mayInterruptIfRunning 为 true 的话，就可以打断运行中的线程
    boolean cancel(boolean mayInterruptIfRunning);

// 返回线程是否已经被取消了，true 表示已经被取消了
// 如果线程已经运行结束了，isCancelled 和 isDone 返回的都是 true
    boolean isCancelled();

// 线程是否已经运行结束了
    boolean isDone();

// 等待结果返回
// 如果任务被取消了，抛 CancellationException 异常
// 如果等待过程中被打断了，抛 InterruptedException 异常
    V get() throws InterruptedException, ExecutionException;

// 等待，但是带有超时时间的，如果超时时间外仍然没有响应，抛 TimeoutException 异常
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

从接口上可以看出，Future 定义了各种方法对任务进行了管理，比如说取消任务，得到任务的
计算结果等等。

十一、RunnableFuture

---

RunnableFuture 也是一个接口，定义如下：

public interface RunnableFuture<V> extends Runnable, Future<V> {
    void run();
}

RunnableFuture接口的最大目的，是让Future可以对Runnable进行处理，可以取消Runnable，查看Runnable是否完成等等。

十二、统一Callable和Runnable

---

前面提到了Runnable会转化为Callable，然后作为FutureTask的属性，FutureTask统一了 Callable 和 Runnable，提供了两者一系列的转化方法。再来看下FutureTask的类定义

FutureTask类定义

---

public class FutureTask<V> implements RunnableFuture<V> {
}

FutureTask 实现了 RunnableFuture 接口，也就是说间接实现了Runnnable 接口（RunnableFuture 实现了 Runnnable 接口）,就是说 FutureTask 本身就是个 Runnnable，同时 FutureTask 也实现了 Future，也就是说 FutureTask 具备对任务进行管理的功能（Future 具备对任务进行管理的功能）。

FutureTask属性

---

 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;  //任务被打断成功

// 组合了 Callable
 private Callable<V> callable;
// 异步线程返回的结果
 private Object outcome; // non-volatile, protected by state reads/writes
// 当前任务所运行的线程
 private volatile Thread runner;
// 记录调用 get 方法时被等待的线程
 private volatile WaitNode waiters;

FutureTask构造器

---

Future两个构造器

//使用 Runnable 初始化，并传入 result 作为返回结果。
// Runnable 是没有返回值的，所以 result 一般没有用，置为 null 就好了
public FutureTask(Runnable runnable, V result) {
    // Executors.callable 方法把runnable适配成 RunnableAdapter，RunnableAdapter 实现了Callable
    this.callable = Executors.callable(runnable, result);
    //任务状态初始化
    this.state = NEW;       // ensure visibility of callable
}
// 使用 Callable 进行初始化
public FutureTask(Callable<V> callable) {
    if (callable == null)
        throw new NullPointerException();
    this.callable = callable;
    //任务状态初始化
    this.state = NEW;       // ensure visibility of callable
}

Runnable的两个构造器，只有一个目的，就是通过Executors.callable把入参转化为RunnableAdapter，主要是因为Callable的功能比Runnable丰富，Callable有返回值，而Runnable没有。

这是一个典型的适配模型，我们要把 Runnable 适配成 Callable，首先要实现 Callable 的接口，接着在 Callable 的 call 方法里面调用被适配对象（Runnable）的方法。

FutureTask对Future 接口方法的实现

---

几个关键的方法实现

get

---

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);
}
// 等待任务执行完成
private int awaitDone(boolean timed, long nanos)
    throws InterruptedException {
    // The code below is very delicate, to achieve these goals:
    // - call nanoTime exactly once for each call to park
    // - if nanos <= 0L, return promptly without allocation or nanoTime
    // - if nanos == Long.MIN_VALUE, don't underflow
    // - if nanos == Long.MAX_VALUE, and nanoTime is non-monotonic
    //   and we suffer a spurious wakeup, we will do no worse than
    //   to park-spin for a while
    long startTime = 0L;    // Special value 0L means not yet parked
    WaitNode q = null;
    boolean queued = false;
    //无限循环
    for (;;) {
        //当前任务状态
        int s = state;
        //当前任务已经执行完了，返回
        if (s > COMPLETING) {
            if (q != null)
                q.thread = null;
            return s;
        }
        //如果正在执行，当前线程让出 cpu，重新竞争，防止cpu飙高
        else if (s == COMPLETING)
            // We may have already promised (via isDone) that we are done
            // so never return empty-handed or throw InterruptedException
            Thread.yield();
        //如果线程已经被打断了，删除，抛异常    
        else if (Thread.interrupted()) {
            removeWaiter(q);
            throw new InterruptedException();
        }
        // 如果第一次运行，新建waitNode，当前线程就是waitNode 的属性
        else if (q == null) {
            if (timed && nanos <= 0L)
                return s;
            q = new WaitNode();
        }
        else if (!queued)
            queued = U.compareAndSwapObject(this, WAITERS,
                                            q.next = waiters, q);
        else if (timed) {
            final long parkNanos;
            if (startTime == 0L) { // first time
                startTime = System.nanoTime();
                if (startTime == 0L)
                    startTime = 1L;
                parkNanos = nanos;
            } else {
                long elapsed = System.nanoTime() - startTime;
                if (elapsed >= nanos) {
                    removeWaiter(q);
                    return state;
                }
                parkNanos = nanos - elapsed;
            }
            // nanoTime may be slow; recheck before parking
            // 没有过超时时间，线程进入TIMED_WAITING状态
            if (state < COMPLETING)
                LockSupport.parkNanos(this, parkNanos);
        }
        else
            LockSupport.park(this);
    }
}

get 方法虽然名字叫做 get，但却做了很多 wait 的事情，当发现任务还在进行中，没有完成时，就会阻塞当前进程，等待任务完成后再返回结果值。阻塞底层使用的是 LockSupport.park方法，使当前线程进入 WAITING 或TIMED_WAITING 状态。

run

---

/**
 * run方法可以直接被调用
 * 也可以开启新的线程调用
 */
public void run() {
// 状态不是任务创建，或者当前任务已经有线程在执行了，直接返回
    if (state != NEW ||
        !U.compareAndSwapObject(this, RUNNER, null, Thread.currentThread()))
        return;
    try {
        Callable<V> c = callable;
        // 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)
            //将result赋值给outcome
                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);
    }
}

1、run方法是没有返回值的，通过给outcome属性赋值（set(result)）,get时就能从outcome属性中拿到返回值。
2、FutureTask 两种构造器，最终都转化成了 Callable，所以在 run 方法执行的时候，只需要执行 Callable 的 call 方法即可，在执行 c.call()代码时，如果入参是 Runnable 的话， 调用路径为 c.call() -> RunnableAdapter.call() -> Runnable.run()，如果入参是 Callable 的话，直接调用。

cancel

---

// 取消任务，如果正在运行，尝试去打断
public boolean cancel(boolean mayInterruptIfRunning) {
    if (!(state == NEW &&//任务状态不是创建，并且不能把new状态置为取消，直接返回false
          U.compareAndSwapInt(this, STATE, NEW,
              mayInterruptIfRunning ? INTERRUPTING : CANCELLED)))
        return false;
    try {    // in case call to interrupt throws exception
       // 进行取消操作，打断可能会抛出异常，选择 try finally 的结构
        if (mayInterruptIfRunning) {
            try {
                Thread t = runner;
                if (t != null)
                    t.interrupt();
            } finally { // final state
            //状态设置成已打断
                U.putOrderedInt(this, STATE, INTERRUPTED);
            }
        }
    } finally {
    // 清理线程
        finishCompletion();
    }
    return true;
}

十三、参考

---

1.面试官系统精讲Java源码及大厂真题

完