java 线程池实现

import java.util.*;
import java.util.concurrent.*;

public class TestThreadPoolService {

    //可用的cpu数量
    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
    //阻塞队列大小
    private static final BlockingQueue<Runnable> WORK_QUEUE = new LinkedBlockingQueue<Runnable>(10*1000);
    // 根据系统配置设置合适的核心线程数、最大线程数、等待队列等参数。
    // 这个需要按照实际业务进行设置，需要考虑当前业务是IO密集和CPU密集
    private static final ExecutorService executor = new ThreadPoolExecutor(CPU_COUNT * 4 + 1, CPU_COUNT * 10 + 1, 1L, TimeUnit.MINUTES, WORK_QUEUE, Executors.defaultThreadFactory(),
            new ThreadPoolExecutor.CallerRunsPolicy()
    );

    /**
     * 业务入口方法
     * @param orderIds
     * @throws InterruptedException
     * @throws ExecutionException
     */
    private void testThreadPool(List<String> orderIds) throws InterruptedException, ExecutionException {
        CompletionService<Map<String,Object>> completionService = new ExecutorCompletionService<>(executor);
        //单号id列表
        List<Future<Map<String,Object>>> futures = new ArrayList<>(orderIds.size());
        //循环添加任务
        for(final String orderId : orderIds){
            futures.add(completionService.submit(new Callable<Map<String,Object>>() {
                @Override
                public Map<String,Object> call(){
                    return targetMethod(orderId);
                }
            }));
        }
        //接受返回结果.这里需要注意返回的顺序可能会跟原始调用顺序不一致，需要通过map的key进行对应处理
        for(int i = 0; i < orderIds.size();i++){
            Map<String,Object> result = completionService.take().get();
            // TODO 拿到对应result后需要进行的业务逻辑
        }
    }

    /**
     * 需要执行的代码
     * @param orderId
     * @return
     */
    private Map<String,Object> targetMethod(String orderId) {
        Map<String,Object> map = new HashMap<>();
        Object result = null;
        // TODO 需要执行的业务
        map.put(orderId,result);
        return map;
    }
}