Spring的线程池技术：ThreadPoolTaskExecutor

package threadPool;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

public class ThreadPoolTest {
    
    // 通过依赖注入注入进来（service层接口或者外围系统接口）
    private BusinessService service;  // = new BusinessServiceImpl();
    // 通过依赖注入注入进来（Spring提供的线程池类）
    private ThreadPoolTaskExecutor taskThreadPool = new ThreadPoolTaskExecutor();

    // 业务方法，供别人调用，真实场景会有参数传进来
    public TaskResp getTasks() {
        
        // 模拟入参
        List<FirstTaskReq> firstReqList = new ArrayList<FirstTaskReq>();
        List<SecondTaskReq> secondReqList = new ArrayList<SecondTaskReq>();
        List<ThirdTaskReq> thirdReqList = new ArrayList<ThirdTaskReq>();
        
        // 定义响应
        TaskResp taskResp = new TaskResp();
        List<FirstTaskResp> firstTaskRespList = new ArrayList<FirstTaskResp>();
        List<SecondTaskResp> secondTaskRespList = new ArrayList<SecondTaskResp>();
        List<ThirdTaskResp> thirdTaskRespList = new ArrayList<ThirdTaskResp>();
        
        // 定义接收任务结果的集合
        ArrayList<FutureTask<Map<String,Object>>> taskList = new ArrayList<FutureTask<Map<String,Object>>>();
        
        if(!firstReqList.isEmpty()) {
            // 通过线程池进行并发操作
            for(FirstTaskReq req : firstReqList) {
                FutureTask<Map<String, Object>> task = new FutureTask<Map<String, Object>>(new FirstTask(req, service));
                taskThreadPool.execute(task);
                // 接收FutrueTask的返回结果
                taskList.add(task);
            }
        }
        
        if(!secondReqList.isEmpty()) {
            // 通过线程池进行并发操作
            for(SecondTaskReq req : secondReqList) {
                FutureTask<Map<String, Object>> task = new FutureTask<Map<String, Object>>(new SecondTask(req, service));
                taskThreadPool.execute(task);
                // 接收FutrueTask的返回结果
                taskList.add(task);
            }
        }

        if(!secondReqList.isEmpty()) {
            // 通过线程池进行并发操作
            for(ThirdTaskReq req : thirdReqList) {
                FutureTask<Map<String, Object>> task = new FutureTask<Map<String, Object>>(new ThirdTask(req, service));
                taskThreadPool.execute(task);
                // 接收FutrueTask的返回结果
                taskList.add(task);
            }
        }
        
        int outTime = 100;
        for(FutureTask<Map<String, Object>> task : taskList) {
            
            try {
                // 获取每一个任务执行结果（每次获取都要等待100毫秒）
                Map<String, Object> returnTasks = task.get(outTime, TimeUnit.MILLISECONDS);
                // 进行业务处理
                if(returnTasks != null && !returnTasks.isEmpty()) {
                    for(Map.Entry<String, Object> returnTask : returnTasks.entrySet()){
                        if(returnTask != null && returnTask.getKey()!=null){
                            String futureKey = returnTask.getKey();
                            if(futureKey.contains("firstTask")){
                                FirstTaskResp firstTaskResp = (FirstTaskResp) returnTask.getValue();
                                firstTaskRespList.add(firstTaskResp);
                            }else if(futureKey.contains("secondTask")){
                                SecondTaskResp secondTaskResp = (SecondTaskResp) returnTask.getValue();
                                secondTaskRespList.add(secondTaskResp);
                            }else if(futureKey.contains("thirdTask")){
                                ThirdTaskResp thirdTaskResp = (ThirdTaskResp) returnTask.getValue();
                                thirdTaskRespList.add(thirdTaskResp);
                            }
                        }
                    }
                }
                
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            } catch (TimeoutException e) {
                e.printStackTrace();
            }
        }
        
        taskResp.setFirstTaskRespList(firstTaskRespList);
        taskResp.setSecondTaskRespList(secondTaskRespList);
        taskResp.setThirdTaskRespList(thirdTaskRespList);
        
        return taskResp;
    }
}

package threadPool;

import java.util.List;

public class TaskResp {
    
    private List<FirstTaskResp> firstTaskRespList;
    private List<SecondTaskResp> secondTaskRespList;
    private List<ThirdTaskResp> thirdTaskRespList;
    
    public List<FirstTaskResp> getFirstTaskRespList() {
        return firstTaskRespList;
    }
    public void setFirstTaskRespList(List<FirstTaskResp> firstTaskRespList) {
        this.firstTaskRespList = firstTaskRespList;
    }
    public List<SecondTaskResp> getSecondTaskRespList() {
        return secondTaskRespList;
    }
    public void setSecondTaskRespList(List<SecondTaskResp> secondTaskRespList) {
        this.secondTaskRespList = secondTaskRespList;
    }
    public List<ThirdTaskResp> getThirdTaskRespList() {
        return thirdTaskRespList;
    }
    public void setThirdTaskRespList(List<ThirdTaskResp> thirdTaskRespList) {
        this.thirdTaskRespList = thirdTaskRespList;
    }

}

package threadPool;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.Callable;

public class FirstTask implements Callable<Map<String, Object>> {
    
    // 请求对象
    private RequestParam param;
    // service层接口或者外围系统接口
    private BusinessService service;
    
    // 构造函数，接收入参
    public FirstTask(RequestParam param, BusinessService service) {
        this.param = param;
        this.service = service;
    }

    @Override
    public Map<String, Object> call() throws Exception {
        
        Map<String, Object> resultMap = new HashMap<String, Object>();
        // 进行接口调用
        BusinessResp businessResp = service.handleBusiness(param);
        // 组装返回值
        resultMap.put("firstTask", businessResp.getFirstTaskResp());
        
        return resultMap;
    }

}

package threadPool;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.Callable;

public class SecondTask implements Callable<Map<String, Object>> {
    
    // 请求对象
    private RequestParam param;
    // service层接口或者外围系统接口
    private BusinessService service;
    
    // 构造函数，接收入参
    public SecondTask(RequestParam param, BusinessService service) {
        this.param = param;
        this.service = service;
    }

    @Override
    public Map<String, Object> call() throws Exception {
        
        Map<String, Object> resultMap = new HashMap<String, Object>();
        // 进行接口调用
        BusinessResp businessResp = service.handleBusiness(param);
        // 组装返回值
        resultMap.put("secondTask", businessResp.getSecondTaskResp());
        
        return resultMap;
    }

}

package threadPool;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.Callable;

public class ThirdTask implements Callable<Map<String, Object>> {
    
    // 请求对象
    private RequestParam param;
    // service层接口或者外围系统接口
    private BusinessService service;
    
    // 构造函数，接收入参
    public ThirdTask(RequestParam param, BusinessService service) {
        this.param = param;
        this.service = service;
    }

    @Override
    public Map<String, Object> call() throws Exception {
        
        Map<String, Object> resultMap = new HashMap<String, Object>();
        // 进行接口调用
        BusinessResp businessResp = service.handleBusiness(param);
        // 组装返回值
        resultMap.put("thirdTask", businessResp.getThirdTaskResp());
        
        return resultMap;
    }

}

package threadPool;

public class RequestParam {

}

package threadPool;

public class FirstTaskReq extends RequestParam {

}

package threadPool;

public class FirstTaskResp extends TaskResp{

}

package threadPool;

public class SecondTaskReq extends RequestParam {

}

package threadPool;

public class SecondTaskResp extends TaskResp{

}

package threadPool;

public class ThirdTaskReq extends RequestParam {

}

package threadPool;

public class ThirdTaskResp extends TaskResp{

}

package threadPool;

public interface BusinessService {

    BusinessResp handleBusiness(RequestParam requestParam);
}

package threadPool;

public class BusinessServiceImpl implements BusinessService {

    @Override
    public BusinessResp handleBusiness(RequestParam requestParam) {
        return null;
    }

}

package threadPool;

public class BusinessResp {

    private FirstTaskResp firstTaskResp;
    private SecondTaskResp secondTaskResp;
    private ThirdTaskResp thirdTaskResp;
    
    public FirstTaskResp getFirstTaskResp() {
        return firstTaskResp;
    }
    public void setFirstTaskResp(FirstTaskResp firstTaskResp) {
        this.firstTaskResp = firstTaskResp;
    }
    public SecondTaskResp getSecondTaskResp() {
        return secondTaskResp;
    }
    public void setSecondTaskResp(SecondTaskResp secondTaskResp) {
        this.secondTaskResp = secondTaskResp;
    }
    public ThirdTaskResp getThirdTaskResp() {
        return thirdTaskResp;
    }
    public void setThirdTaskResp(ThirdTaskResp thirdTaskResp) {
        this.thirdTaskResp = thirdTaskResp;
    }
    
}

 <bean id="taskThreadPool" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor" >
        <!-- 核心线程数  -->
        <property name="corePoolSize" value="8" />
        <!-- 最大线程数 -->
        <property name="maxPoolSize" value="16" />
        <!-- 队列最大长度 >=mainExecutor.maxSize -->
        <property name="queueCapacity" value="200" />
        <!-- 线程池维护线程所允许的空闲时间 -->
        <property name="keepAliveSeconds" value="300" />
        <!-- 线程池对拒绝任务(无线程可用)的处理策略 -->
        <property name="rejectedExecutionHandler">
            <bean class="java.util.concurrent.ThreadPoolExecutor$AbortPolicy" />
        </property>
    </bean>