关于CompletableFuture结合函数式编程的并行工具类

import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * 并行任务执行工具类
 *
 */
public class ParallelUtils {

    /**
     * 无返回值类型
     *
     * @param list 并行任务集合
     * @param task 任务处理方式
     * @param threads 并发数量
     * @param <T> 入参类型
     */
    public static <T> void execute(List<T> list, Consumer<T> task, int... threads) {

        // 设置并行线程数
        int nThreads = threads.length == 0 ? Runtime.getRuntime().availableProcessors() : threads[0];

        // 创建固定线程池
        ExecutorService executor = Executors.newFixedThreadPool(nThreads);

        // 定义 function
        Function<T, CompletableFuture<Void>> function = item -> CompletableFuture.runAsync(() -> task.accept(item), executor);

        try {
            // 等待所有任务执行结束
            CompletableFuture.allOf(list.stream().map(function).toArray(CompletableFuture[]::new)).join();
        } finally {
            // 关闭线程池
            executor.shutdown();
        }
    }

public static void main(String[] args) throws Exception {
    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 12);
    Function<Integer, String> function = item -> (1 / item) + "_";
    List<String> strings = executeTasksInParallel(list, function);
}

    /**
     * 有返回值类型
     *
     * @param list 并行任务集合
     * @param task 任务处理方式
     * @param threads 并发数量            
     * @param <T> 入参类型
     * @param <R> 出参类型
     */
    public static <T, R> List<R> execute(List<T> list, Function<T, R> task, int... threads) throws Exception {

        // 设置并行线程数
        int nThreads = threads.length == 0 ? Runtime.getRuntime().availableProcessors() : threads[0];

        // 创建固定线程池
        ExecutorService executor = Executors.newFixedThreadPool(nThreads);

        // 创建任务处理方式
        Function<T, CompletableFuture<R>> function = item -> CompletableFuture.supplyAsync(() -> task.apply(item), executor);

        // 将每个输入项转换成CompletableFuture，使其并行执行
        List<CompletableFuture<R>> futures = list.stream().map(function).collect(Collectors.toList());

        // 将所有阶段合并成一个新的Future中的阶段
        CompletableFuture<Void> allFutures = allOf(futures);

        try {
            // 将所有结果合并到列表中
            Function<Void, List<R>> fn = v -> futures.stream().map(CompletableFuture::join).collect(Collectors.toList());

            // 等待所有任务执行结束
            return allFutures.thenApplyAsync(fn).get();
        } finally {
            // 确保线程池被关闭
            executor.shutdown();
        }
    }

    public static CompletableFuture<Void> allOf(List<? extends CompletableFuture<?>> futures) {
        CompletableFuture<?>[] futureArray = new CompletableFuture<?>[futures.size()];
        for (int i = 0; i < futures.size(); i++) {
            futureArray[i] = futures.get(i);
        }
        return CompletableFuture.allOf(futureArray);
    }
}