【Java】guava（二） ListenableFuture 使用及原理

使用异步编程接口获取返回值的方式有两种：

1.同步方式，也就是调用方主动获取，但是这时可能还没有返回结果，可能需要轮询；

2.回调方式，调用者在提交任务时，注册一个回调函数，任务执行完以后，自动触发回调函数通知调用者；这种实现方式需要在执行框架里植入一个扩展点，用于触发回调。

Java原生api里的Future属于第一种，Java8提供的CompletableFuture属于第二种；在Java8出来之前，guava也提供了基于回调的编程接口，也就是本次要说的ListenableFuture（其实看guava代码，里面有大量这玩意儿，不搞懂不行。。。）。

先看下ListenableFuture接口定义：

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

可以看到，这个接口在Future接口的基础上增加了addListener方法，允许我们注册回调函数。当然，我们在编程时可能不会直接使用这个接口，因为这个接口只能传Runnable实例。Futures类提供了另一个方法：addCallback方法。下面我们看一个实例：

@Test
public void test55() throws InterruptedException {
    ListenableFuture<String> s = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(1))
            .submit(() -> {
                Thread.sleep(2000L);
                return "async result";
            });

    Futures.addCallback(s, new FutureCallback<String>() {
        @Override
        public void onSuccess(@Nullable String result) {
            System.out.println("succeed, result: {}" + result);
        }

        @Override
        public void onFailure(Throwable t) {
            System.out.println("failed, t: " + t);
        }
    }, Executors.newSingleThreadExecutor());
    Thread.sleep(100000);
}

首先看下addCallback方法干了啥？

public static <V> void addCallback(
  final ListenableFuture<V> future,
  final FutureCallback<? super V> callback,
  Executor executor) {
Preconditions.checkNotNull(callback);
future.addListener(new CallbackListener<V>(future, callback), executor);
}

这里调用了ListenableFuture接口的addListener方法，传入了一个CallbackListener实例。而这个实例由需要传入future和一个Callback实例，所以这个回调是可以拿到返回值的。本质上是guava帮我们基于Runnable封了一个回调接口。看下这个CallbackListener接口：

private static final class CallbackListener<V> implements Runnable {
    final Future<V> future;
    final FutureCallback<? super V> callback;

    CallbackListener(Future<V> future, FutureCallback<? super V> callback) {
      this.future = future;
      this.callback = callback;
    }

    @Override
    public void run() {
      if (future instanceof InternalFutureFailureAccess) {
        Throwable failure =
            InternalFutures.tryInternalFastPathGetFailure((InternalFutureFailureAccess) future);
        if (failure != null) {
          callback.onFailure(failure);
          return;
        }
      }
      final V value;
      try {
        value = getDone(future);
      } catch (ExecutionException e) {
        callback.onFailure(e.getCause());
        return;
      } catch (RuntimeException | Error e) {
        callback.onFailure(e);
        return;
      }
      callback.onSuccess(value);
    }
}

这个类内部有一个future和一个FutureCallback实例，其run方法就是回调时的逻辑，先调用getDone方法获取future的返回值。然后再将返回值调用FutureCallback实例的onSuccess方法执行注册的回调逻辑。当然，如果发生了异常，则会调用onFailure方法通知异常。

好的，至此我们已经了解了用户注册的回调函数是怎么执行的了，那么还有一个重要问题，这个回调是怎么触发的？

在开始的时候大致提了一下，回调的实现一般都是在执行框架层植入一个扩展点，触发回调逻辑，这里也不意外。我们从执行的执行框架入手，开始的时候我们调用MoreExecutors构造了一个线程池:

@GwtIncompatible // TODO
public static ListeningExecutorService listeningDecorator(ExecutorService delegate) {
return (delegate instanceof ListeningExecutorService)
    ? (ListeningExecutorService) delegate
    : (delegate instanceof ScheduledExecutorService)
        ? new ScheduledListeningDecorator((ScheduledExecutorService) delegate)
        : new ListeningDecorator(delegate);
}

对于我们之前的例子，会返回一个ListeningDecorator类型的线程池，从方法命名也可以看出，这个本质上就是对于Java原生线程池的一个封装，用于返回ListenableFuture类型的Future：

  private static class ListeningDecorator extends AbstractListeningExecutorService {
    private final ExecutorService delegate;

    ListeningDecorator(ExecutorService delegate) {
      this.delegate = checkNotNull(delegate);
    }

    @Override
    public final boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
      return delegate.awaitTermination(timeout, unit);
    }

    @Override
    public final boolean isShutdown() {
      return delegate.isShutdown();
    }

    @Override
    public final boolean isTerminated() {
      return delegate.isTerminated();
    }

    @Override
    public final void shutdown() {
      delegate.shutdown();
    }

    @Override
    public final List<Runnable> shutdownNow() {
      return delegate.shutdownNow();
    }

    @Override
    public final void execute(Runnable command) {
      delegate.execute(command);
    }
  }
}

这个家伙儿啥也没干，就是将执行逻辑委托给了delegate。当然，线程池执行不仅仅是这些方法，比如最开始的submit方法，其实是在其父类AbstractListeningExecutorService中的：

  @Override
  public <T> ListenableFuture<T> submit(Callable<T> task) {
    return (ListenableFuture<T>) super.submit(task);
  }

然后又调用了AbstractListeningExecutorService的父类即Java中原生的AbstractExecutorService的submit方法，进入了原生Java的逻辑。之后会调用newTask创建任务：

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

guava的AbstractListeningExecutorService覆盖了newTaskFor方法，这样才能返回ListenableFuture呀：

  @Override
  protected final <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
    return TrustedListenableFutureTask.create(callable);
  }

所以，guava里的ListenableFuture的一个实现类是这里的TrustedListenableFutureTask，这个我们不做深入，直接看其run方法吧，也是在父类里定义的，这个方法很长，截取一段关键逻辑：

try {
  if (run) {
    result = runInterruptibly();
  }
} catch (Throwable t) {
  error = t;
} finally {
  }
  if (run) {
    afterRanInterruptibly(result, error);
  }
}

先调用runInterruptibly方法执行任务内容，然后如果执行成功就调用afterxxx方法执行一个后置的逻辑，这个其实就是我们所说的“植入点”，主动调用回调的入口就是这个方法：

@Override
void afterRanInterruptibly(V result, Throwable error) {
  if (error == null) {
    TrustedListenableFutureTask.this.set(result);
  } else {
    setException(error);
  }
}

如果有异常，设置Exception，否则设置返回值。我们只看无异常的case:

@CanIgnoreReturnValue
protected boolean set(@Nullable V value) {
Object valueToSet = value == null ? NULL : value;
if (ATOMIC_HELPER.casValue(this, null, valueToSet)) {
  complete(this);
  return true;
}
return false;
}

这里在任务里设置完返回值后，就调用了complete方法，只截取关键逻辑：

/** Unblocks all threads and runs all listeners. */
private static void complete(AbstractFuture<?> future) {
Listener next = null;
outer:
while (true) {
  future.afterDone();
  next = future.clearListeners(next);
  future = null;
  while (next != null) {
    Listener curr = next;
    next = next.next;
    Runnable task = curr.task;
    if (task instanceof SetFuture) {
    } else {
      executeListener(task, curr.executor);
    }
  }
  break;
}

这里的Listener就是最开始添加到Future里的回调函数，是一个链表结构。这个方法会遍历回调链表，逐一调用executeListener方法触发回调逻辑。

至此ListenableFuture的回调逻辑基本清楚了。

 

小结：

1.优先使用Futures工具类添加回调；

2.回调的实现，在执行框架内植入触发逻辑；