简介
建议先对不同层面的异步 有一点感觉
Future jdk源码中的接口定义与描述
interface Future<T>{
boolean cancel(boolean mayInterruptIfRunning);
boolean isCancelled();
boolean isDone();
V get() throws InterruptedException, ExecutionException;
V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;
}
A Future represents the result of an asynchronous computation. Methods are provided to check if the computation is complete, to wait for its completion, and to retrieve the result of the computation. The result can only be retrieved using method get when the computation has completed, blocking if necessary until it is ready. Cancellation is performed by the cancel method. Additional methods are provided to determine if the task completed normally or was cancelled. Once a computation has completed, the computation cannot be cancelled.
相比同步执行，为什么需要future？
- 为异步调用提供一种语法。否则，异步调用，就只有callback一种形式。
- 想中断或取消任务（通过由框架的扩展提供）
对future的理解
2019.1.17 补充
- 彻底理解Java的Future模式 单线程就不说了，在多线程中，你另起线程执行一个任务，Runnable.run 是没有返回值的。从调用方的角度看，另起线程是为了加快处理，不意味着不关心执行结果。 调用方可以先不管 返回结果干别的，但不意味着永远不关心返回结果。所以调用方要有获取返回结果的手段，甚至于影响执行线程的手段（比如取消）。 了解了这个，就会对那么多future的扩充类找到感觉，因为它们都是从调用者需求出发的。
- Interface Future A Future represents the result of an asynchronous computation.
- Guide to java.util.concurrent.Futurefuture 一般与Callable 和ExecutorService 结合使用。 Callable is an interface representing a task that returns a result and has a single call() method. Creating an instance of Callable does not take us anywhere, we still have to pass this instance to an executor that will take care of starting that task in a new thread and give us back the valuable Future object. That’s where ExecutorService comes in.
- 自己的理解：凡是异步，必涉及调用方和执行方（通常还有队列），两方必涉及沟通媒介，类似于“句柄” 之类的东东。
java自带的future
任务的取消、关闭和结果的访问
《java并发编程实战》第二部分的着重讲了任务的执行和取消与关闭，我们常关注如何启动线程。几个执行体如何触发执行
- Runnable，
new Thread(xx).start()没办法直接到拿到运算结果 - Callable，
ExecutorService.submit(xx)通过返回值拿到返回结果 - FutureTask，
new Thread(xx).start通过get方法拿到返回结果
前两者只有thread运行完毕才知道（或能够访问）运算任务的结果，而FutureTask的返回结果通过get方法一封装，我们就有机会在任务的开始前、开始后和结束后访问运算结果，毕竟调用方并不知道任务现在在哪个阶段，这个给了调用方代码很大的灵活性。
任务的取消和关闭也是如此。我们理解一个Future的关键，一个切入点就是它如何取消一个线程的执行。
取消一个任务本质上两个方法（当然，任务已经结束就无法取消了）：
-
线程run方法里有interrupt判断，在另外一个地方拿到线程的引用thread，然后
thread.interrupt()class XXThread extends Thread{ void run(){ try{ while(!Thread.currentThread().isInterrupted()){ // 干活 } }catch(InterruptedException e){ /* 允许线程退出 */ } } public void cancel(){interrupt();} } -
线程run方法在实际执行前，会判断state。那么能改变state即可。但如果线程被阻塞，无法执行state判断逻辑，那也只能干看着了（每个线程都有一个boolean类型的中断状态，大部分阻塞库方法比如Object.wait、Thread.sleep是支持检查interrupt状态的）。
可以看到，任务取消的实现，需要线程代码符合一定的约定。所以要实现Future接口的方法，意味着我们要更大程度的介入线程的执行（或者说run方法中提供更多的埋点）。FutureTask兴许就是为了将这些约定描述清楚、固化下来。
FutureTask
我们来看一个Futrue的简单使用
ExecutorService executor = Executors.newFixedThreadPool();
Future<Integer> future = executor.submit(new MyJob()));
跟踪submit方法所属的类，Executors.newFixedThreadPool() ==> ThreadPoolExecutor ==> AbstractExecutorService
public <T> Future<T> submit(Callable<T> task) {
if (task == null) throw new NullPointerException();
RunnableFuture<T> ftask = newTaskFor(task);
execute(ftask);
return ftask;
}
protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
return new FutureTask<T>(runnable, value);
}
返回的future是一个FutureTask，FutureTask是interface RunnableFuture<V> extends Runnable, Future<V>的实现类。
以FutureTask为例，future如何取消一个任务。
executor执行FutureTask，最终运行的是FutureTask的run方法，那么在FutureTask的run方法中埋一些点（加一些检测），在cancel方法中改变下状态值就可以影响run方法的执行（如果此时这个run方法被某个线程执行）。
FutureTask的特别之处是它同时拥有run和cancel方法，所以执行cancel可以影响run方法的执行。那么，其它Future的实现类如何实现cancel呢？
future的扩展
guava ListenableFuture和AbstractFuture
ListenableFuture的简单使用
ListeningExecutorService executorService = MoreExecutors.listeningDecorator(Executors.newCachedThreadPool());
final ListenableFuture<Integer> listenableFuture = executorService.submit(new MyJob<Integer>());
// 添加监听事件
Futures.addCallback(listenableFuture, new FutureCallback() {
public void onSuccess(Integer result) {
}
public void onFailure(Throwable thrown) {
}
});
跟踪submit方法所属的类，ListeningExecutorService ==> AbstractListeningExecutorService ==> AbstractExecutorService
public abstract class AbstractListeningExecutorService extends AbstractExecutorService{
protected final <T> ListenableFutureTask<T> newTaskFor(Runnable runnable, T value){
return ListenableFutureTask.create(runnable, value);
}
public <T> ListenableFuture<T> submit(Callable<T> task) {
return (ListenableFuture)super.submit(task);
}
}
public abstract class AbstractExecutorService implements ExecutorService{
public <T> Future<T> submit(Callable<T> task) {
if (task == null) throw new NullPointerException();
RunnableFuture<T> ftask = newTaskFor(task);
execute(ftask);
return ftask;
}
}
实际执行的submit方法和上节的submit方法一样一样的，但在submit方法中，上节执行的是AbstractExecutorService.newTaskFor返回FutureTask，此处执行的是AbstractListeningExecutorService.newTaskFor返回ListenableFutureTask，其实际也是个java.util.concurrent.FutureTask。所以一个ListenableFuture具有cancel的能力就不奇怪了。看来本质上，ListenableFutureTask取消任务的方式还是和FutureTask一样。
ListenableFuture所具备的addListener方法则是任务挂在一个地方，当run方法执行完毕后，执行这些任务。（不同的guava版本实现代码有很大不同）
可以设置结果的Future
FutureTask中，get方法和run方法共享成员变量outcome，所以run方法跑完，设置下outcome，get方法就可以拿到返回outcome。（当然，涉及到状态判断与线程安全问题）
在可以设置结果的Future中，比如netty的Promise，outcome除run方法可以设置外，还提供了set方法设置outcome（当然，涉及到状态判断与线程安全问题）。
通常，我们将notifyListeners的操作放到set方法中，比如NettyPromise的实现
public Promise<V> setSuccess(V result){
if(setSuccess0(result)){
// 集中在set方法中触发listener
notifyListeners();
return this;
}
throw new ILLegalStateExeception("complete already : " + this);
}
多线程中的future
在java库提供的Future实现中，其本质是FutureTask，即既包含执行逻辑，又包含对执行逻辑的控制（获取结果和取消等）。
而有些框架（主要是io框架）的Future实现中，Future只是两个线程间共享数据的载体（future简化了线程间的并发访问），包含线程安全的设置与获取结果的方法（或者说，只是对一个Object或变量的封装Future<Object>，使其安全访问），本身不是FutureTask，不包含执行逻辑。
在多线程环境下，经常会使用callback进行异步操作，两者有什么不同呢？
ThreadA{
private Object value;
func(){
value.code1()
obj.function(callback(){
value.code2()
});
}
}
在ThreadA中运行func，value.code1()在threadA中运行，value.code2()有可能在另一个线程中运行，会有潜在的线程安全问题，future则将这个问题隐式的解决了。
io框架中的future
在io框架中，我们通常需要建立future与业务收发数据（以下称为message）的关联。比如Future send(Message)，其实现通常是
map<long,future> futureManager
sendThead{
Future send(Message){
Future future = new Future();
futureManager.put(message.getId(),future);
ioBusiness.send(message);
}
}
receiveThread{
void receive(message){
// 收发的同一个message必须具备相同的id
Future future = futureManager.get(message.getId());
future.setResult();
}
}
// 一般会有一个定时线程，对过期的futureManager数据进行清理，执行future.cancel。防止future.get过长时间无法响应。