线程池小计

线程池的管理过程：首先创建一个线程池，然后根据任务的数量逐步将线程增大到corePoolSize，如果此时仍有任务增加，则放置到workQueue中，直到workQueue爆满为止，然后继续增加池中的线程数量（增强处理能力），最终达到maxinumPoolSize。那如果此时还有任务要增加进来呢？这就需要handler来处理了，或者丢弃新任务，或者拒绝新任务，或者挤占已有的任务。在任务队列和线程池都饱和的情况下，一旦有线程处于等待（任务处理完毕，没有新任务）状态的时间超过keepAliveTime，则该线程终止，也就是说池中的线程数量会逐渐降低，直至为corePoolSize数量为止。

newFixedThreadPool 固定线程池使用

场景介绍

    在一个业务逻辑中需要同时生成7份合同（pdf）格式，在生成合同的同时，
    不仅需要调用一些外部接口去获取合同中的参数信息，而且还需要调用个人签章
    和企业签章去合同中生成。这样调用一个合同的时间就很长了，一个大概也需要3-4s，
    那么如果顺序执行7个，完成就需要20几s。这样接口响应就会需要很长时间来完成。

解决办法

    1／异步调用生成合同接口
    2／在异步调用接口的同时，采用线程池的方式同时创建7个线程去同时生成7个合同。
    这样既省时间又可以很快给用户作出响应。

ExecutorService executor = Executors.newFixedThreadPool(7);

        Future<Boolean> f = executor.submit(() -> {
            try{
                return generatePuchase(contractNo);

            }catch (Exception e){
                logger.error("生成咨询服务协议失败",e);
                return false;
            }
        });

        Future<Boolean> f1=executor.submit(() -> {
            try{
                return generateEntrustment(contractNo);
            }catch (Exception e){
                logger.error("生成划扣协议书失败",e);
                return false;
            }
        });

        Future<Boolean> f2=executor.submit(() -> {
            try{
                return  generatePromise(contractNo);
            }catch (Exception e){
                logger.error("生成用户承诺函失败",e);
                return  false;
            }

        });

        Future<Boolean> f3=executor.submit(() -> {
            try{
                return generateUserConfirm(contractNo);
            }catch (Exception e){
                logger.error("生成用户确认书失败",e);
                return  false;
            }
        });

        Future<Boolean> f4=executor.submit(() -> {
            try{
                return  generateTrust(contractNo);

            }catch (Exception e){
                logger.error("生成委托协议书失败",e);
                return  false;
            }
        });
        Future<Boolean> f5=executor.submit(() -> {
            try{
                return   generateHjConfirm(contractNo);

            }catch (Exception e){
                logger.error("生成用户确认书失败",e);
                return  false;
            }
        });

        Future<Boolean> f6=executor.submit(() -> {
            try{
                return  generateLend(contractNo);

            }catch (Exception e){
                logger.error("生成借款合同失败",e);
                return  false;
            }
        });


        for(;;){
            if(f.isDone() && f1.isDone() && f2.isDone() && f3.isDone() && f4.isDone() && f5.isDone() && f6.isDone()){
                try {
                    if(f.get() && f1.get() && f2.get() && f3.get() && f4.get() && f5.get() && f6.get() ){
                        //7个合同同时生成完成后再调用签约借款2
                        //调用签约接口
                        String signUrl=insideServiceUrl+CommonConstants.INSIDE_FR_SIGN_URL+orderId;
                        logger.info("调用签约地址为{}",signUrl);
                        CommonResponseResult commonResponseResult=oAuth2RestTemplate.getForObject(signUrl,CommonResponseResult.class);
                        if("00000".equals(commonResponseResult.getCode())){
                            logger.info("订单ID为{}调用签约接口成功",orderId);
                        }else if("99999".equals(commonResponseResult.getCode())){
                            logger.info("订单ID为{}调用签约接口失败",orderId);
                        }
                        break;
                    }

                } catch (InterruptedException e) {
                    logger.error("线程执行出错1",e);
                } catch (ExecutionException e) {
                    logger.error("线程执行出错2",e);

                }
            }
        }

简单解析：for循环需要持续循环等待7个线程全部执行完毕，
并且返回结果全部为true时才去调用签约接口。亲测没有问题，很快
其中的：Future.get()    Waits if necessary for the computation to complete, and then retrieves its result.