作用和举例

future类的作用就是为了调用其他线程完成好后的结果，再返回到当前线程中，如上图举例：

小王自己是主线程，叫外卖等于使用future类，叫好外卖后小王就接着干自己的事去了，当外卖到了的时候，future.get获取，继续做接下来的事情

但要注意的是当还没获取外卖的时候，主线程中用餐这一步是卡住的

JDK中的Future实现

结构如下

常用方法：

• cancel()：如果等太久，你可以直接取消这个任务
• isCancelled()：任务是不是已经取消了
• isDone()：任务是不是已经完成了
• get()：有2个get()方法，不带参数的表示无穷等待，或者你可以只等待给定时间

使用：

	//异步操作 可以用一个线程池ExecutorService executor = Executors.newFixedThreadPool(1);//执行FutureTask，相当于上例中的 client.request("name") 发送请求//在这里开启线程进行RealData的call()执行Future<String> future = executor.submit(new RealData("name"));System.out.println("请求完毕，数据准备中");try {//这里依然可以做额外的数据操作，这里使用sleep代替其他业务逻辑的处理Thread.sleep(2000);} catch (InterruptedException e) {}//如果此时call()方法没有执行完成，则依然会等待System.out.println("数据 = " + future.get());

executor.submit()里传线程类

走这里看源码

	public <T> Future<T> submit(Callable<T> task) {if (task == null) throw new NullPointerException();// 根据Callable对象，创建一个RunnableFuture，这里其实就是FutureTaskRunnableFuture<T> ftask = newTaskFor(task);//将ftask推送到线程池//在新线程中执行的，就是run()方法，在下面的代码中有给出execute(ftask);//返回这个Future，将来通过这个Future就可以得到执行的结果return ftask;}protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {return new FutureTask<T>(callable);}

RunnableFuture其实就是FutureTask

FutureTask作为一个线程单独执行时，会将结果保存到outcome中，并设置任务的状态,下面是FutureTask的run()方法：

Future类最关键的get实现

FutureTask源码

outcome类：保存的就是最终的计算结果，get/set里都有它

实现自己的Future模式

还是用敖丙的例子，主要实现类如下：

先定义接口

public interface Data {public String getResult ();
}

实现自己的future类：

public class FutureData implements Data {// 内部需要维护RealDataprotected RealData realdata = null;          protected boolean isReady = false;public synchronized void setRealData(RealData realdata) {if (isReady) { return;}this.realdata = realdata;isReady = true;//RealData已经被注入，通知getResult()notifyAll();                            			}//会等待RealData构造完成public synchronized String getResult() {        	while (!isReady) {try {//一直等待，直到RealData被注入wait();                        			} catch (InterruptedException e) {}}//真正需要的数据从RealData获取return realdata.result;                    		}
}

关键在于isReady这个布尔，while (!isReady)作为自旋锁，想要获取这个future的结果，他会一直等待，直到RealData被注入

RealData类：

public class RealData implements Data {protected final String result;public RealData(String para) {StringBuffer sb=new StringBuffer();//假设这里很慢很慢，构造RealData不是一个容易的事result =sb.toString();}public String getResult() {return result;}
}

Client类，目的是将RealData注入到FutureData

public class Client {//这是一个异步方法，返回的Data接口是一个Futurepublic Data request(final String queryStr) {final FutureData future = new FutureData();new Thread() {                                      public void run() {                    	// RealData的构建很慢，所以在单独的线程中进行RealData realdata = new RealData(queryStr);//setRealData()的时候会notify()等待在这个future上的对象future.setRealData(realdata);}                                               }.start();// FutureData会被立即返回，不会等待RealData被构造完return future;                        		}
}

mian方法通过data.getResult()拿数据

public static void main(String[] args) {Client client = new Client();//这里会立即返回，因为得到的是FutureData而不是RealDataData data = client.request("name");System.out.println("请求完毕");try {//这里可以用一个sleep代替了对其他业务逻辑的处理//在处理这些业务逻辑的过程中，RealData被创建，从而充分利用了等待时间Thread.sleep(2000);} catch (InterruptedException e) {}//使用真实的数据，如果到这里数据还没有准备好，getResult()会等待数据准备完，再返回System.out.println("数据 = " + data.getResult());
}

参考：
JAVA Future类详解