模拟Future模式

多线程里的Future模式的主要特点是，一个大的业务中，有好多耗时比较多的任务，如果按照顺序一个一个的完成，所用的时间就是所有的任务耗时累和，但是其实有一些任务是可以并行执行的，所以不必一个任务一个任务逐一完成，只需要另外开线程做任务，当需要任务结果时获取结果数据就ok了。简单说就是主任务向下执行，具体到某个小任务的时候，开一个线程不阻塞异步执行。

 如图，需要有一个客户端来发送请求，需要有一个Data接口，FutureData是包装类，客户端请求返回的数据，实际上就是这个包装类，还需要一个真实处理数据的类RealData，把RealData的处理数据返回给FutureData，返回给客户端，这样任务流程就结束了。

 

首先，客户端，Data接口，如下

public interface Data {
	//获取请求结果
	String getRequest();
}

然后定义FutureData和RealData，他们都实现了Data

public class FutureData implements Data{

	@Override
	public String getRequset() {
		return null;
	}

}

public class RealData implements Data{

	@Override
	public String getRequset() {
		return null;
	}

}

 

定义客户端,通过查询参数，返回包装类。

public class FutureClient {
	public Data request(final String queryStr) {
		FutureData futureData = new FutureData();
		
		return futureData;
	}
}

定义测试类

public class Main {
	public static void main(String[] args) {
		long startTime = System.currentTimeMillis();
		FutureClient fc = new FutureClient();
		Data data = fc.request("请求参数.."); //异步执行 非阻塞的
		
		System.err.println("做其他相关操作..");
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		String ret = data.getRequest(); //真正获取数据的方法
		System.err.println("-------------," + ret + ",用时 "+ (System.currentTimeMillis() - startTime) + "毫秒");
		
	}
}

我们假设包装类调用的真实处理数据类RealData处理数据时间为5秒，按顺序客户端继续执行，处理3秒其他业务，再拿到包装类的结果，实际上这个时间应该是5+3 = 8 秒...但是，FutureData那一块不应该阻塞，这样5秒 3秒，实际最长时间应该是5秒多一点点。这是Future模式理论上的处理结果。

继续代码实现....

FutureClient类完整实现如下，因为要返回FutureData这个包装对象，而有不能阻塞，只能重起一个线程异步处理，这个线程中需要用到RealData来真正的处理数据，也就是5秒的真实处理逻辑的部分。我们认为RealData对象new出来之后，就是业务处理完成了，这时把RealData对象设置成FutureData的成员变量。客户端调用的getRequest方法返回的实际上就是RealData的数据了。

public class FutureClient {

	
		public Data request(final String queryStr) {
			FutureData futureData = new FutureData();
			
			//异步的起一个线程去进行响应的处理
			new Thread(new Runnable() {
				@Override
				public void run() {
					//需要把请求参数设置到真实的数据处理对象中
					RealData realData = new RealData(queryStr);
					//真是请求处理完成以后，要进行设置结果给包装类对象
					futureData.setRealData(realData);
				}
			}).start();
			
			return futureData;
		}
}

FutureData类的完整实现如下，我们认为RealData对象创建完成后，就是5秒的业务逻辑完成了，就给RealData赋值，isReady设为ture，表示数据已经处理完成，可以获取数据了。这个时候其实应该唤醒获取数据的方法，因为有可能还能处理完数据，就去获取了，这样肯定获取不到，所以需要唤醒获取数据的方法，当然，获取数据的方法也要首先判断isReady，没准备好肯定要wait。

public class FutureData implements Data{

	private RealData realData;
	
	//数据是否已经准备好了
	private boolean isReady = false;
	
	public synchronized void setRealData(RealData realData) {
		if(isReady) {
			return ;
		}
		
		//如果真实对象赋值成功，说明数据已经准备好了
		this.realData = realData;
		isReady = true;
		//唤醒
		notify();
	}
	
	@Override
	public synchronized String getRequest() {
		while(!isReady) {
			try {
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		return this.realData.getRequest();
	}
	

}

RealData的完整处理过程如下

public class RealData implements Data{

	private String result;
	public RealData(String queryStr) {
		System.err.println("真是的处理数据对象,获取到的请求参数为 " + queryStr + "，可能需要处理3-5秒左右...");
		try {
			Thread.sleep(5000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		this.result = "100条数据";
	}

	@Override
	public String getRequest() {
		return this.result;
	}

}

 这样，执行测试类Main,结果如下

实际用时5005毫秒，符合预期。。。。

这就是Future模式