java多线程模式：Future模式

Future模式类似于商品订单。当在网购时，下了一个订单后，我们可以做其他事情，等待商品送货上门即可。或者就像在页面上使用ajax请求的时候，页面的一些内容是异步的向后台发请求，我们可以正常的浏览页面其他内容。Future模式的图如下。

 客户端发送一个耗时请求，服务端不需等待该数据处理完成便立即返回一个伪造的代理数据，先去执行其他的若干操作后，再去调用服务器已经完成组装的真实数据。该模式充分利用了等待的时间片段。

代码如下：

Data接口，FutureData和RealData的超类

 

public interface Data {
	
	Object getResult();
	
}

 

真实数据的代理类FutureData，它需要真实数据的引用，因为需要通过它来获取真实数据

 

 

public class FutureData implements Data {

	private RealData realData;
	
	private Boolean isDone = false;
	
	public synchronized void setRealData(RealData realData) {
		if (isDone) {
			return;
		}
		this.realData = realData;
		isDone = true;
		notifyAll();
	}
	
	
	@Override
	public synchronized Object getResult() {
		while (!isDone) {
			try {
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		return realData.getResult();
	}

}

 

 

 

 

 

setRealData方法和getResult方法是互斥的，当调用getReult方法获取处理结果时候，需要等待setRealData方法执行完毕，将结果设置成功。

 

真实数据RealData：

 

public class RealData implements Data {

	private Object result;
	
	private Object param;
	
	
	public RealData(Object param) {
		this.param = param;
	}
	
	@Override
	public Object getResult() {
		
		return result;
	}
	
	private void setResult(Object result) {
		this.result = result;
	}
	
	public void Handle() {
		try {
			//假装在忙
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		setResult(param.toString() + ": 处理结果");
	}
	
}

 

 

 

future客户端 ：

 

 

 

 

public class FutureClient {

	FutureData futureData = new FutureData();
	public Data request(final Object param) {
		
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				RealData realData = new RealData(param);
				realData.Handle();
				futureData.setRealData(realData);
				
			}
		}).start();
		
		return futureData;
	}
	
	

}

该处启用了一个线程来处理数据，也就是获取RealData，返回了FutureData，而FutureData又包含了RealData的引用，可以获取数据处理结果。

 

接下来做个测试：

 

public class FutureDataTest {

	public static void main(String[] args) {
		
		FutureClient fc = new FutureClient();
		Data futureData = fc.request("参数");
		String a = "做我自己的事情...";
		System.out.println(a);
		System.out.println(a + futureData.getResult());
		
	}
}

然而，在使用过程中，我们不需要写复杂的这个过程，jdk提供了Future实现方式。

 

 

public static void main(String[] args) {
		
		ExecutorService executor = Executors.newCachedThreadPool();
		Future<String> future = executor.submit(new Callable<String>() {
			
			public String call() {
				try {
					Thread.sleep(5000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				return "future处理结果";
			}});
		String a = "做我自己的事情...";
		System.out.println(a);
		while(true) {
			if (future.isDone()) {
				String res = null;
				try {
					res = future.get();
					a = a + res;
				} catch (InterruptedException e) {
					e.printStackTrace();
				} catch (ExecutionException e) {
					e.printStackTrace();
				}
				break;
			}
		}
		System.out.println(a);
		executor.shutdown();
		
	}

Callable接口，是不是感觉和Runable接口有些像，只不过Runable接口需要重写run方法，而Callable接口需要重写calll方法，并且call方法具有返回值。这也说明了两个接口的区别：

 

在并发编程时，使用runnable，然后扔给线程池完事，这种情况下不需要线程的结果。所以run的返回值是void类型。而callable是需要返回结果的。
你可能会有疑问：再获取真实数据时不是仍然需要等待数据处理完吗？要知道，你可以用这个时间做一些其他事情，等到真正需要真实数据时候再去获取。