1.future模式-多线程结合设计模式

博客概述

并行设计模式属于设计优化的一部分，它是对一些常用的多线程结构的总结和抽象。与串行程序相比，并行程序的结构通常更为复杂。因此合理的使用并行模式在多线程开发中更具有意义。在本文中主要介绍future模式。

future模式实现

什么是future模式

该模式有点类似于商品订单，比如在网购的时候，当看中某一件商品时，就可以提交订单，当订单处理完成以后，在家里等待送货上门即可。或者说更形象的我们发送ajax请求的时候，页面是异步的进行后台处理，用户无需一直等待请求处理的结果，可以继续浏览或者操作其他内容。jdk底层提供了future类。future模式类似ajax的异步，思想是一致的。

业务场景

在耗时操作时，将业务拆分，在不同的线程进行。用future模式，最后汇总的时候再用真实数据汇总。
空间（内存）换时间的策略来解决问题。其实并不是那么简单。关键是知道哪一块业务可以这么做。
如果业务之间需要互相的结果，可能就不能并行执行。开发系统难点在于：业务和技术结合。

jdk的api实现案例

 /**
     * 功能描述: 当你不能拆分业务，只能一个一个算，这种情景，用这种模式=脱裤子放屁。
     *             但是，如果业务流可以拆分，最后汇总给用户，future模式就变的成为一把尖刀。
     * @auther: 李泽
     * @date: 2019/4/5 23:08
     */
    @Test
    public  void FutureTest(){
        //获得只有一个线程的线程池
        ExecutorService service = Executors.newSingleThreadExecutor();
        //获得回调，会直接返回，实际上后台在执行耗时的业务逻辑
        Future<String> future = service.submit(new Callable<String>() {
            @Override
            public String call() throws Exception {
                //模拟耗时的逻辑
                TimeUnit.SECONDS.sleep(2);
                return "hello";
            }
        });
        System.out.println("等待结果");
        try {
            //程序会阻塞在这等待执行结果
            //System.out.println("future = " + future.get());
            //最佳实践：看有没有结果，没有就不等。超时就报错TimeoutException
            System.out.println("future = " + future.get(1,TimeUnit.SECONDS));
         }catch (Exception e){
             e.printStackTrace();
         }
    }

自己设计实现future模式

主函数

public static void main(String[] args) throws InterruptedException {
		
		FutureClient fc = new FutureClient();
		Data data = fc.request("请求参数");
		System.out.println("请求发送成功!");
		System.out.println("做其他的事情...");
		
		String result = data.getRequest();
		System.out.println(result);
		
	}

数据接口（明星的功能，经纪人对外也是有的，实际是明星干活，但是经纪人对外打交道）

public interface Data {

	String getRequest();

}

真正的数据对象（经纪人管理下的明星，负责去演出，具体干活）

public class RealData implements Data{

	private String result ;
	//在构造函数里进行复杂的业务逻辑
	public RealData (String queryStr){
		System.out.println("根据" + queryStr + "进行查询，这是一个很耗时的操作..");
		try {
			Thread.sleep(5000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("操作完毕，获取结果");
		result = "查询结果";
	}
	//根据个人的理解，构造函数一定要在该方法之前执行。
	@Override
	public String getRequest() {
		return result;
	}

}

FutureClient

public class FutureClient {

	public Data request(final String queryStr){
		//1 我想要一个代理对象（Data接口的实现类）先返回给发送请求的客户端，告诉他请求已经接收到，可以做其他的事情
		final FutureData futureData = new FutureData();
		//2 启动一个新的线程，去加载真实的数据，传递给这个代理对象
		new Thread(new Runnable() {
			@Override
			public void run() {
				//3 这个新的线程可以去慢慢的加载真实对象，然后传递给代理对象.这个new的过程是耗时的
				RealData realData = new RealData(queryStr);
				futureData.setRealData(realData);
			}
		}).start();
		
		return futureData;
	}
	
}

FutureData代理对象（经纪人）

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() {
		//如果没装载好 程序就一直处于阻塞状态。因为可能程序装载好之前，就有其他线程需要data，这样的话就得先阻塞。等装载好了之后，再唤醒。
		while(!isReady){
			try {
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		//装载好直接获取数据即可
		return this.realData.getRequest();
	}


}

返回的是引用，实际的值在后台计算。
计算完毕之后，在设置给data对象。
wait和notify做的延迟处理。