核心思想
异步调用。先拿到一个Future，然后根据Future拿真实数据。
示例1
public interface Data {
String getResult();
}
/**
* 这是关键类，包装了RealData，代替RealData先返回。
* 通过该类获取RealData，如果RealData结果出来则直接返回，如果还没有则阻塞等待。
*/
public class FutureData implements Data {
/**包装RealData*/
protected RealData realData = null;
protected boolean isReady = false;
public synchronized void setRealData(RealData realData) {
if (isReady) {
return;
}
this.realData = realData;
this.isReady = true;
// RealData已经被注入，通知getResult()
notifyAll();
}
@Override
public synchronized String getResult() {
// 等待RealData构造完成
while (!isReady) {
try {
// 一直等待，RealData被注入
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
return realData.getResult();
}
}
public class RealData implements Data {
protected final String result;
public RealData(String result) {
// RealData的构造可能很慢，需要等待很久，这里使用Sleep模拟。
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.result = result;
}
@Override
public String getResult() {
return result;
}
}
public class Client {
public Data request(String queryStr) {
FutureData futureData = new FutureData();
//RealData构建很慢，单开线程。
new Thread(()->{
RealData realData = new RealData(queryStr);
futureData.setRealData(realData);
}).start();
//FutureData立即返回
return futureData;
}
}
public class Test {
public static void main(String[] args) throws InterruptedException {
Client client = new Client();
//立即返回得到的是FutureData，稍后通过这个FutureData的getResult获取RealData
Data data = client.request("baozi-request");
//这里模拟其他业务的处理，在这个过程中RealData慢慢构建成功
Thread.sleep(2000);
System.out.println("获取RealData："+data.getResult());
}
}
示例2 JDK内置
FutureTask代替Callable先返回，稍后通过FutureTask获取Callable获取的数据。
import java.util.concurrent.Callable;
public class RealData implements Callable<String> {
@Override
public String call() throws Exception {
//RealData的构造可能很慢，需要等待很久，这里使用Sleep模拟。
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "callable";
}
}
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;
public class Test {
public static void main(String[] args) throws InterruptedException, ExecutionException {
FutureTask<String> futureTask = new FutureTask<String>(new RealData());
ExecutorService es = Executors.newFixedThreadPool(1);
// FutureTask执行Callable，开启线程进行RealData的call执行
es.submit(futureTask);
// 这里模拟其他业务的处理，在这个过程中RealData慢慢构建成功
Thread.sleep(2000);
// 再次说明，先构建FutureTask，然后通过FutureTask执行Callable获取返回值
// 1.如果Callable没有返回则等待，2.已返回则返回
System.out.println("call:"+futureTask.get());
es.shutdown();
}
}
