【Java高并发学习】Future模式

Future模式

1.Future模式

核心思想：异步调用
当调用某一个函数时，如果该函数执行时间很长，但又不需要及时获取结果。可以让被调用者立即返回，让它后台继续处理，此时调用者可以先处理其他任务，等到需要时再尝试获取需要的数据。
利用等待时间，取处理其他任务，从而提高系统的响应速度。
以下为Future模式结构图。

2.Future模式简单实现例子

/**
* 希望获取的数据
* @author wsz
* @date 2018年1月3日
*/
public interface Data {
String getResult();
}

/**
* 真实数据RealData的代理，封装了获取RealData的等待过程
* @author wsz
* @date 2018年1月3日
*/
public class FutureData implements Data{

protected RealData realdata = null;   //进行包装RealData

protected boolean isReady = false;

public synchronized void setRealData(RealData realdata) {
if(isReady) {
return;
}
this.realdata = realdata;
isReady = true;
notifyAll();   //RealData已经注入，通知getResult()
}

@Override
public synchronized String getResult() {
while(!isReady) {
try {
wait();			//一直等待，直到RealData被注入并唤醒
}catch(InterruptedException e) {
e.printStackTrace();
}
}
return realdata.result;  //返回真正的RealData
}
}

import java.util.concurrent.Callable;

public class RealData implements Callable<String>{

private String para;

public RealData(String para) {
super();
this.para = para;
}

@Override
public String call() throws Exception {
StringBuffer sb = new StringBuffer();
for(int i =0 ;i <10; i++) {
sb.append(para);
Thread.sleep(100);
}
return sb.toString();
}

}

public class Client {

public Data request(final String queryStr) {
final FutureData future = new FutureData();
new Thread() {	//RealData的构造很慢，在单独的线程中进行
public void run() {
RealData realdata = new RealData(queryStr);
future.setRealData(realdata);
}
}.start();;
return future;
}

public static void main(String[] args) {
Client client = new Client();
Data data = client.request("test");//这里会立即返回，因为得到的是FutureData而不是RealData
System.out.println("请求完毕");
//		System.out.println(data.getResult());构造较慢，有明显的延迟
try {
Thread.sleep(2000);  //模拟其他业务逻辑的处理过程，该过程中RealData被创建
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(data.getResult());//真实数据
}
}

3.JDK中的Future模式

import java.util.concurrent.Callable;
/**
* 真实数据，实现Callable接口
* @author wsz
* @date 2018年1月3日
*/
public class RealData implements Callable<String>{

private String para;

public RealData(String para) {
super();
this.para = para;
}

@Override
public String call() throws Exception {
StringBuffer sb = new StringBuffer();
for(int i =0 ;i <10; i++) {
sb.append(para);
Thread.sleep(100);
}
return sb.toString();
}
}

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;
/**
* @author wsz
* @date 2018年1月3日
*/
public class FutureMain {

public static vo
4000
id main(String[] args) throws InterruptedException, ExecutionException {
//构造FutureTask
FutureTask<String> future = new FutureTask<String>(new RealData("test"));
ExecutorService executor = Executors.newFixedThreadPool(1);
//执行FutureTask，相当于client.request("test")
//开启线程进行RealData的call
executor.submit(future);

System.out.println("请求完毕");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(future.get());
}
}