lambda表达式基于线程池的性能处理方案

import com.google.common.collect.Lists;
import lombok.extern.slf4j.Slf4j;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.function.Consumer;

public class demo {

    public static void main(String[] args) {
        demo demo = new demo();
        demo.batchUrge(Lists.asList("1","2","3"));
    }

    //入口
    public void batchUrge(List<String> input) {
        List<String> itemResultList = new ArrayList<>();
        String ss="港咩啊";
        Factory.Executor.invoke((caze) -> dodo(ss,caze,itemResultList),
            input,
            3L,
            TimeUnit.SECONDS);
    }

    private void dodo(String actor, String caseId,List<String> itemResultList) {
        System.out.println("干活+"+caseId);
    }


}

class Factory {

    public static ThreadPoolLimiterExecutor Executor = new ThreadPoolLimiterExecutor(5,
        50,
        2L,
        TimeUnit.MINUTES,
        "BatchOptEnum.BATCH_URGE",
        5);
}

@Slf4j
class ThreadPoolLimiterExecutor {

    private int preMaxThreadNum = 1;

    private String invokerName = null;

    private ThreadPoolExecutor executor = null;

    /**
     * 创建线程池
     *
     * @param corePoolSize
     * @param maximumPoolSize
     * @param keepAliveTime
     * @param unit
     * @param batchOptEnum
     * @param preMaxThreadNum
     */
    public ThreadPoolLimiterExecutor(int corePoolSize,
        int maximumPoolSize,
        long keepAliveTime,
        TimeUnit unit,
        String batchOptEnum,
        int preMaxThreadNum) {
        if (preMaxThreadNum > 0) {
            this.preMaxThreadNum = preMaxThreadNum;
        }

        this.invokerName = batchOptEnum == null ? "defaultInvoker" : "batchOptEnum.getCode()";

        this.executor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize,
            keepAliveTime, unit,
            new SynchronousQueue<>(),
            Executors.defaultThreadFactory(),
            new ThreadPoolExecutor.CallerRunsPolicy());
    }

    public <P> void invoke(Consumer<P> callable, List<P> params, long timeout, TimeUnit unit) {
        if (params == null || params.size() <= 0) {
            return;
        }

        if (params.size() == 1) {
            callable.accept(params.get(0));
            return;
        }

        int groupNum = getGroupNum(params);

        List<Callable<Void>> callableList = new ArrayList<>(this.preMaxThreadNum);
        for (List<P> group : ListUtil.splitList(params, groupNum)) {
            if (group == null || group.size() <= 0) {
                continue;
            }

            callableList.add(() -> {
                List<Throwable> throwableList = new ArrayList<>();
                for (P p : group) {
                    try {
                        callable.accept(p);
                    } catch (Throwable e) {
                        throwableList.add(e);
                    }
                }
                if (throwableList.size() > 0) {
                    throw new RuntimeException("并行执行多个callable抛出异常");
                }

                return null;
            });
        }

        try {
            List<Future<Void>> futures = executor.invokeAll(callableList, timeout, unit);
            if (futures.size() > 0) {
                for (Future<Void> f : futures) {
                    if (f == null || f.isDone()) {
                        continue;
                    }

                    try {
                        f.get(timeout, unit);
                    } catch (TimeoutException | ExecutionException e) {
                        e.printStackTrace();
                    }
                }
            }
        } catch (InterruptedException e) {
            log.error("ThreadPoolLimiterExecutor.query invokeAll error", e);
        }
    }

    private <P> int getGroupNum(List<P> params) {
        return params.size() / this.preMaxThreadNum + 1;
    }



}

class ListUtil {

    public static <T> List<List<T>> splitList(List<T> list, int len) {
        if (list == null) {
            return null;
        }

        len = len < 1 ? 1 : len;

        List<List<T>> result = new ArrayList<List<T>>();
        if (list.size() == 0) {
            result.add(list);
            return result;
        }

        int size = list.size();
        int count = (size + len - 1) / len;

        for (int i = 0; i < count; i++) {
            List<T> subList = list.subList(i * len, ((i + 1) * len > size ? size : len * (i + 1)));
            result.add(subList);
        }
        return result;
    }
}