并行程序设计模式-Future模式

定义：Future模式类似商品订单，客户下单后，卖家在准备商品和物流配送过程需要很多时间，这段时间内客户可以先做其他事，收到订单后，再处理订单；

案例：JDK内部实现的Future模式，FutureTask类

代码实现：

主业务（耗时较长）：

@Service
public class FutureService{
    public String dealRealData(String key,int[] data) throws InterruptedException {
        //耗时较长
        Thread.sleep(1000);
        System.out.println(key+":正在处理真实的业务逻辑");
        int a=0;
        for(int i=0,len=data.length;i<len;i++){
            a=a+data[i];
        }
        return a+"";
    }
}

辅助业务，与主业务数据无关联

@Service
public class FutureClicent {
    public void deal(String key){
        //再真实业务处理时，可以在等待主要业务进行的同时，先干点其他的事
        System.out.println(key+":正在处理辅助辅助业务");
    }
}

主业务代理工具

public class FutureUtil implements Callable {
    private FutureService futureService;
    private String key;
    private int[] data;
    public FutureUtil(FutureService futureService,String key,int[] data){
        this.futureService=futureService;
        this.key=key;
        this.data=data;
    }
    @Override
    public Object call() throws Exception {
        //处理真是业务逻辑
        return futureService.dealRealData(key,data);
    }
}

客户端调用：

@RestController
@RequestMapping(value = "/chat/app/test")
public class TestAppController {
    private FutureService futureService;
    private FutureClicent futureClicent;
    public TestAppController(FutureService futureService, FutureClicent futureClicent){
        this.futureService=futureService;
        this.futureClicent=futureClicent;
    }
     @PostMapping(value="test")
     public void Test(){
        deal("A",new int[]{1,2,3});
        deal("B",new int[]{7,8,2,3});
     }

     private void deal(String key,int[] b){
        new Thread(){
            @Override
            public void run() {
                FutureTask<String> futureTask=new FutureTask<String>(new FutureUtil(futureService,key,b));
                ExecutorService service= Executors.newFixedThreadPool(1);
                service.submit(futureTask);
                futureClicent.deal(key);
                try {
                    System.out.println(key+":处理完结果，返回主要业务逻辑结果："+futureTask.get());
                    System.out.println(key+":结束");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (ExecutionException e) {
                    e.printStackTrace();
                }
            }
        }.start();
     }
}

实现结果：

A:正在处理辅助辅助业务
B:正在处理辅助辅助业务
A:正在处理真实的业务逻辑
A:处理完结果，返回主要业务逻辑结果：6
A:结束
B:正在处理真实的业务逻辑
B:处理完结果，返回主要业务逻辑结果：20
B:结束