简单的多线程工具类

• 需要实现功能:

  • * 实现功能
    *   1.多线程处理, 传入枚举,实现定制线程池
    *   2.有返回结果的
    *   3.可以允许部分成功

枚举:

       

/**
 *  线程池常用枚举
 *
 * @author: Lenovo
 * @date: 2021/8/3
 * @description:
 */
public enum ThreadNormalEnum {

    /**
     * 常用线程池配置
     */
    NORMAL_THREAD(5,20,100),
    /**
     * 大线程池配置
     */
    BIGDATA_THREAD(50,200,1000);

    /**
     * 核心线程池大小
     */
    private int coreSize;

    /**
     * 最大线程池大小
     */
    private int maxSize;

    /**
     * 队列大小
     */
    private int queueSize;

    ThreadNormalEnum(int coreSize, int maxSize, int queueSize) {
        this.coreSize = coreSize;
        this.maxSize = maxSize;
        this.queueSize = queueSize;
    }

    ThreadNormalEnum() {
    }

    public int getCoreSize() {
        return coreSize;
    }

    public int getMaxSize() {
        return maxSize;
    }

    public int getQueueSize() {
        return queueSize;
    }
}

具体工具类

/**
 * 线程池工具类
 *
 *     *   1.多线程处理, 传入枚举,实现定制线程池
 *      *   2.有返回结果的
 *      *   3.可以允许部分成功
 * @author: Lenovo
 * @date: 2021/8/3
 * @description:
 */
public class ThreadPoolUtil {

    /**
     * 线程池 缓存
     */
    private static final Map<String, ThreadPoolExecutor> THREAD_MAP = new ConcurrentHashMap();

    static {
        THREAD_MAP.put(ThreadNormalEnum.NORMAL_THREAD.name(), getThreadPool(ThreadNormalEnum.NORMAL_THREAD));
    }

    private static ThreadPoolExecutor getThreadPool(ThreadNormalEnum threadNormalEnum) {
        //返回默认值
        if (ObjectUtil.isNull(threadNormalEnum)) {
            return THREAD_MAP.get(ThreadNormalEnum.NORMAL_THREAD.name());
        }
        //缓存中获取
        ThreadPoolExecutor threadPoolExecutor = MapUtil.emptyIfNull(THREAD_MAP).get(threadNormalEnum.name());
        if (ObjectUtil.isNotNull(threadPoolExecutor)) {
            return threadPoolExecutor;
        }

        int coreSize = threadNormalEnum.getCoreSize();
        int maxSize = threadNormalEnum.getMaxSize();
        int queueSize = threadNormalEnum.getQueueSize();
        //设置线程池工厂名称
        ThreadFactory springThreadFactory = new CustomizableThreadFactory(threadNormalEnum.name());
        //默认拒绝策略, 抛异常
        ThreadPoolExecutor newThreadPoolExecutor = new ThreadPoolExecutor(coreSize, maxSize, 6, TimeUnit.SECONDS, new LinkedBlockingQueue<>(queueSize), springThreadFactory);
        //添加缓存
        THREAD_MAP.put(threadNormalEnum.name(),newThreadPoolExecutor);
        return newThreadPoolExecutor;
    }

    /**
     *  具体执行方法
     *
     * @param params    传入的参数list
     * @param func      具体执行方法
     * @param threadNormalEnum  参数枚举
     * @param exceptionFlag 是否支持部分成功
     * @param <T>   参数类型
     * @param <R>   返回结果类型
     * @return   List<R>
     */
    public static<T,R>   List<R>  doExecute(List<T> params, Function<T,R> func, ThreadNormalEnum threadNormalEnum,boolean exceptionFlag){
        //通过枚举 获取线程池
        ThreadPoolExecutor threadPool = getThreadPool(threadNormalEnum);
        List<Callable<R>> tasks = new ArrayList<>();
        ArrayList<R> resultList = CollUtil.newArrayList();
        for (T param : params) {
            tasks.add(new Callable<R>() {
                @Override
                public R call() throws Exception {
                    return func.apply(param);
                }
            });
        }
        try {
           List<Future<R>>  submit =  threadPool.invokeAll(tasks);
            for (Future<R> stringFuture : submit) {
                try {
                    R result = stringFuture.get();
                    resultList.add(result);
                } catch (ExecutionException e) {
                    e.printStackTrace();
                    if (exceptionFlag){
                        resultList.add(null);
                    }else {
                        throw new RuntimeException(e);
                    }
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        return resultList;


    }


}

测试:

/**
 * @author: Lenovo
 * @date: 2021/8/2
 * @description:
 */
public class ThreadTest {
    public static void main(String[] args) {
        ArrayList<String> strings = CollUtil.newArrayList();

        for (int i = 0; i < 5000; i++) {
            strings.add(i+"");
        }

        List<List<Integer>> stringList = ThreadPoolUtil.doExecute(strings, s -> {
            return addString(s);
        }, ThreadNormalEnum.BIGDATA_THREAD, true);


        System.out.println(stringList);


    }
    public  static  List<Integer> addString(String s){

        return CollUtil.newArrayList(Integer.parseInt(s));
    }
}