异步回调详解

简介

随着移动互联网的蓬勃发展，业务架构也随之变得错综复杂，业务系统越来越多。通常，我们处理方法是异步去调取这些接口。随着高并发系统越来越多，异步回调模式也越来越重要。

问题就来了，如何获取处理异步调用的结果呢 ？让我们一起来探讨一下吧～～

Java Future的异步回调

Callable接口

在聊Callable接口之前，先提一下Runnable接口。Runnable接口是在Java多线程中表示线程的业务代码的抽象接口。但是Runnable没有返回值，为了解决这个问题，Java定义了一个和Runnable类似的接口 --- Callable接口。并将业务处理方法名为call

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

Callable接口是一个范型接口，也声明为了函数式接口。唯一的抽象方法call有返回值，返回值类型为范型形参的实际类型

初探FutureTask类

故名思意，FutureTask类代表一个未来执行的任务，表示新线程执行的操作。同时也位于java.util.concurrent包中。源码如下：

public class FutureTask implements RunnableFuture {
    public FutureTask(Callable callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;       // ensure visibility of callable
    }
}

FutureTask类就像一座搭在Callable实例与Thread线程实例之间的桥。FutureTask内部封装了一个Callable实例，然后自身又作为Thread线程的target。

Future接口

Future接口并不复杂，主要是对并发任务的执行及获取其结果的一些操作。主要有三大功能。

• 判断并发任务是否执行完。
• 获取并发的任务完成后的结果
• 取消并发执行的任务

package java.util.concurrent;
public interface Future {
  boolean cancel(boolean mayInterruptIfRunning);
  boolean isCancelled();
  boolean isDone();
  V get() throws InterruptedException, ExecutionException;
  V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

详细说法如下：

• V get()：获取并发任务执行的结果。这个方法是阻塞的，如果并发任务没有执行完成调用此方法的线程会一直阻塞
• V get(Long timeout, TimeUtil unit)：获取并发任务执行的结果。也是阻塞的，但是有阻塞的时间限制，如果阻塞时间超过设定的时间，该方法将会抛出异常
• boolean isDone()：获取并发任务的状态是否结束
• boolean isCancelled()：获取并发任务的取消状态。如果任务被取消返回true
• boolean cancel(boolean mayInterruptIfRunning)：取消并发任务的执行

再探FutureTask类

在FutureTask类中，有一个Callable的私有成员，Futuretask内部有一个run方法。这个run方法是Runable接口的抽象方法，在FutureTask类的内部提供了自己的实现。在Thread线程实例执行时，会将这个run方法作为target目标去异步执行。在FutureTask内部的run方法中实际是会执行Callable的call方法。

执行完后结果会保存在私有成员-- outcome属性中

private Object outcome; // non-volatile, protected by state reads/writes

outcome负责保存结果。然后FutureTask通过get方法获取这个object的值，那这个FutureTask的任务也就能成功完成了。

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)
        // 将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);
  }
}

实例

package com.zou;

import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;


public class futureTask {
    public static void main(String[] args) throws Exception {
        FutureTask TaskA = new FutureTask<>(() -> {
            try {
                TimeUnit.SECONDS.sleep(2);
                System.out.println("A任务准备好了");
            } catch (Exception e) {
                System.out.println("A任务出问题了");
                return false;
            }
            System.out.println("A任务运行结束");
            return true;
        });

        FutureTask TaskB = new FutureTask<>(() -> {
            try {
                TimeUnit.SECONDS.sleep(4);
                System.out.println("B任务准备好了");
            } catch (Exception e) {
                System.out.println("B任务出问题了");
                return false;
            }
            System.out.println("B任务运行结束");
            return true;
        });

        Thread threadA = new Thread(TaskA);
        Thread threadB = new Thread(TaskB);

        threadA.start();
        threadB.start();

        Thread.currentThread().setName("主线程");
        try {
            boolean a = TaskA.get();
            boolean b = TaskB.get();
            isReady(a, b);
        } catch (Exception e) {
            System.out.println("发生了中断");
        }
        System.out.println("运行结束");
    }
    public static void isReady(boolean a, boolean b) {
        if (a && b) {
            System.out.println("都准备好了");
        } else if (!a) {
            System.out.println("A没准备好");
        } else {
            System.out.println("B没准备好");
        }
    }
}

运行结果为：

A任务准备好了
A任务运行结束
B任务准备好了
B任务运行结束
都准备好了
运行结束

要是将上面的代码跑一下会发现，这里的FutureTask类的get方法，异步获取结果的同时，主线程是阻塞的。所以可以将其归为异步阻塞模式。

异步阻塞的效率往往是比较低的，被阻塞的主线程不能干任何事。并没有实现非阻塞的异步结果获取方法。如果需要用到获取异步结果，则需要引入一些框架，先介绍一下Google的Guava框架

Guava的异步回调

Guava是Google提供的Java扩展包，提供一种异步回调的解决方案。相关的源码在com.google.common.util.concurrent包中。包中很多类，都是对java.util.concurrent能力的扩展和增强。比如Guava的异步任务接口ListenableFuture, 实现了非阻塞获取异步结果的功能。

对于异步回调，Guava主要做了以下增强：

• 引入一个新的接口ListenableFuture，继承了Java的Future接口，使得Java的Future异步任务，在Guava中能被监控和获得非阻塞异步执行的结果。
• 引入一个新的接口FutureCallback，这是一个独立的新接口。该接口的目的是在异步任务执行完成后，根据异步结果，完成不同的回调处理，并且可以处理回调结果。

详解FutureCallback

FutureCallback是一个新增的接口，用来填写异步任务执行完后的监听逻辑。有两个回调方法：

• onSuccess方法，在异步任务执行成功后回调；调用时，异步任务的执行结果作为onSuccess方法的参数传入
• onFailure方法，在异步任务执行过程中，抛出异常时被回调；调用时异步任务所抛出的异常，作为onFailure方法的参数传入。

FutureCallback的源代码如下：

public interface FutureCallback {
  /** Invoked with the result of the {@code Future} computation when it is successful. */
  void onSuccess(@Nullable V result);

  /**
   * Invoked when a {@code Future} computation fails or is canceled.
   *
   * 
If the future's {@link Future#get() get} method throws an {@link ExecutionException}, then
   * the cause is passed to this method. Any other thrown object is passed unaltered.
   */
  void onFailure(Throwable t);
}

注意，Guava的FutureCallable与Java的Callable，名字相近，但实质不同，存在本质的区别：

1. Java的Callable接口，代表的是一部执行的逻辑
2. Guava的FutureCallback接口，代表的是Callable异步逻辑执行完之后，根据成功或者失败的两种情况的善后工作

那么问题来了，Guava如何实现异步任务Callable和FutureCallable结果回调之间的监控关系呢？Guava引入了一个新接口ListenableFuture，它继承了Java的Future接口，增强了监控能力。

详解ListenableFuture

Guava的ListenableFuture接口是对Java的Future接口的扩展，可以理解为异步任务的实例。源代码如下：

public interface ListenableFuture extends Future {
  void addListener(Runnable listener, Executor executor);
}

ListenableFuture仅仅增加了一个方法 -- addListener方法。他的作用是将前一小节的FutureCallback善后回调工作，封装成一个内部的Runnable异步回调任务，在Callable异步任务完成后，回调FutureCallback进行善后处理

在实际编程中，如何将FutureCallback回调逻辑绑定到异步的ListenableFuture任务呢？可以使用Guaba的Futures工具类，他有一个addCallback静态方法，可以将FutureCallback的回调实例绑定到ListenableFuture异步任务。类似这样的绑定：

Futures.addCallback(ListenableFuture, new FutureCallback