package util;
import java.time.Duration;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.*;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collectors;
/**
* CompletableFuture工具类，提供高性能的多线程编排功能
* 支持自定义线程池和虚拟线程
*/
public class CompletableFutureUtils {
/**
* 默认线程池 - 使用ForkJoinPool.commonPool()作为默认执行器
* ForkJoinPool采用工作窃取算法，适合CPU密集型任务
*/
private static final Executor DEFAULT_EXECUTOR = ForkJoinPool.commonPool();
/**
* 创建虚拟线程执行器（需要Java 21+）
* 虚拟线程适合IO密集型任务，可以创建大量线程而不会消耗过多系统资源
*
* @return 虚拟线程执行器
*/
public static Executor virtualThreadExecutor() {
return Executors.newVirtualThreadPerTaskExecutor();
}
/**
* 创建自定义线程池
*
* @param corePoolSize 核心线程数
* @param maxPoolSize 最大线程数
* @param keepAliveTime 空闲线程存活时间（秒）
* @param queueCapacity 任务队列容量
* @param threadNamePrefix 线程名前缀
* @return 自定义线程池
*/
public static ThreadPoolExecutor createThreadPool(
int corePoolSize,
int maxPoolSize,
long keepAliveTime,
int queueCapacity,
String threadNamePrefix) {
return new ThreadPoolExecutor(
corePoolSize,
maxPoolSize,
keepAliveTime,
TimeUnit.SECONDS,
new LinkedBlockingQueue<>(queueCapacity),
r -> {
Thread thread = new Thread(r);
thread.setName(threadNamePrefix + "-" + thread.getId());
return thread;
},
new ThreadPoolExecutor.CallerRunsPolicy()
);
}
/**
* 异步执行任务
*
* @param supplier 任务提供者
* @param executor 执行器，如果为null则使用默认执行器
* @param <T> 返回值类型
* @return CompletableFuture对象
*/
public static <T> CompletableFuture<T> supplyAsync(Supplier<T> supplier, Executor executor) {
return CompletableFuture.supplyAsync(supplier, executor != null ? executor : DEFAULT_EXECUTOR);
}
/**
* 使用默认执行器异步执行任务
*
* @param supplier 任务提供者
* @param <T> 返回值类型
* @return CompletableFuture对象
*/
public static <T> CompletableFuture<T> supplyAsync(Supplier<T> supplier) {
return supplyAsync(supplier, null);
}
/**
* 异步执行无返回值的任务
*
* @param runnable 任务
* @param executor 执行器，如果为null则使用默认执行器
* @return CompletableFuture对象
*/
public static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor) {
return CompletableFuture.runAsync(runnable, executor != null ? executor : DEFAULT_EXECUTOR);
}
/**
* 使用默认执行器异步执行无返回值的任务
*
* @param runnable 任务
* @return CompletableFuture对象
*/
public static CompletableFuture<Void> runAsync(Runnable runnable) {
return runAsync(runnable, null);
}
/**
* 等待所有CompletableFuture完成并收集结果
*
* @param futures CompletableFuture集合
* @param <T> 返回值类型
* @return 包含所有结果的CompletableFuture
*/
public static <T> CompletableFuture<List<T>> allOf(Collection<CompletableFuture<T>> futures) {
CompletableFuture<Void> allFutures = CompletableFuture.allOf(
futures.toArray(new CompletableFuture[0]));
return allFutures.thenApply(v ->
futures.stream()
.map(CompletableFuture::join)
.collect(Collectors.toList())
);
}
/**
* 执行多个任务并等待所有完成
*
* @param suppliers 任务提供者列表
* @param executor 执行器
* @param <T> 返回值类型
* @return 包含所有结果的CompletableFuture
*/
public static <T> CompletableFuture<List<T>> allOf(
Collection<Supplier<T>> suppliers, Executor executor) {
List<CompletableFuture<T>> futures = suppliers.stream()
.map(supplier -> supplyAsync(supplier, executor))
.collect(Collectors.toList());
return allOf(futures);
}
/**
* 使用默认执行器执行多个任务并等待所有完成
*
* @param suppliers 任务提供者列表
* @param <T> 返回值类型
* @return 包含所有结果的CompletableFuture
*/
public static <T> CompletableFuture<List<T>> allOf(Collection<Supplier<T>> suppliers) {
return allOf(suppliers, null);
}
/**
* 等待任意一个CompletableFuture完成并返回其结果
*
* @param futures CompletableFuture集合
* @param <T> 返回值类型
* @return 最先完成的CompletableFuture的结果
*/
@SafeVarargs
public static <T> CompletableFuture<T> anyOf(CompletableFuture<T>... futures) {
return CompletableFuture.anyOf(futures).thenApply(o -> (T) o);
}
/**
* 执行多个任务并等待任意一个完成
*
* @param suppliers 任务提供者列表
* @param executor 执行器
* @param <T> 返回值类型
* @return 最先完成的任务的结果
*/
@SuppressWarnings("unchecked")
public static <T> CompletableFuture<T> anyOf(
Collection<Supplier<T>> suppliers, Executor executor) {
CompletableFuture<T>[] futures = suppliers.stream()
.map(supplier -> supplyAsync(supplier, executor))
.toArray(CompletableFuture[]::new);
return (CompletableFuture<T>) CompletableFuture.anyOf(futures);
}
/**
* 使用默认执行器执行多个任务并等待任意一个完成
*
* @param suppliers 任务提供者列表
* @param <T> 返回值类型
* @return 最先完成的任务的结果
*/
public static <T> CompletableFuture<T> anyOf(Collection<Supplier<T>> suppliers) {
return anyOf(suppliers, null);
}
/**
* 异步应用函数转换CompletableFuture的结果
*
* @param future CompletableFuture对象
* @param function 转换函数
* @param executor 执行器
* @param <T> 输入类型
* @param <U> 输出类型
* @return 转换后的CompletableFuture
*/
public static <T, U> CompletableFuture<U> thenApplyAsync(
CompletableFuture<T> future,
Function<T, U> function,
Executor executor) {
return future.thenApplyAsync(function, executor != null ? executor : DEFAULT_EXECUTOR);
}
/**
* 使用默认执行器异步应用函数转换CompletableFuture的结果
*
* @param future CompletableFuture对象
* @param function 转换函数
* @param <T> 输入类型
* @param <U> 输出类型
* @return 转换后的CompletableFuture
*/
public static <T, U> CompletableFuture<U> thenApplyAsync(
CompletableFuture<T> future,
Function<T, U> function) {
return thenApplyAsync(future, function, null);
}
/**
* 异步组合两个CompletableFuture的结果
*
* @param future1 第一个CompletableFuture
* @param future2 第二个CompletableFuture
* @param combiner 组合函数
* @param executor 执行器
* @param <T> 第一个CompletableFuture的结果类型
* @param <U> 第二个CompletableFuture的结果类型
* @param <V> 组合后的结果类型
* @return 组合后的CompletableFuture
*/
public static <T, U, V> CompletableFuture<V> thenCombineAsync(
CompletableFuture<T> future1,
CompletableFuture<U> future2,
BiFunction<T, U, V> combiner,
Executor executor) {
return future1.thenCombineAsync(future2, combiner,
executor != null ? executor : DEFAULT_EXECUTOR);
}
/**
* 使用默认执行器异步组合两个CompletableFuture的结果
*
* @param future1 第一个CompletableFuture
* @param future2 第二个CompletableFuture
* @param combiner 组合函数
* @param <T> 第一个CompletableFuture的结果类型
* @param <U> 第二个CompletableFuture的结果类型
* @param <V> 组合后的结果类型
* @return 组合后的CompletableFuture
*/
public static <T, U, V> CompletableFuture<V> thenCombineAsync(
CompletableFuture<T> future1,
CompletableFuture<U> future2,
BiFunction<T, U, V> combiner) {
return thenCombineAsync(future1, future2, combiner, null);
}
/**
* 异步处理CompletableFuture的结果
*
* @param future CompletableFuture对象
* @param action 处理动作
* @param executor 执行器
* @param <T> 结果类型
* @return CompletableFuture对象
*/
public static <T> CompletableFuture<Void> thenAcceptAsync(
CompletableFuture<T> future,
java.util.function.Consumer<T> action,
Executor executor) {
return future.thenAcceptAsync(action, executor != null ? executor : DEFAULT_EXECUTOR);
}
/**
* 使用默认执行器异步处理CompletableFuture的结果
*
* @param future CompletableFuture对象
* @param action 处理动作
* @param <T> 结果类型
* @return CompletableFuture对象
*/
public static <T> CompletableFuture<Void> thenAcceptAsync(
CompletableFuture<T> future,
java.util.function.Consumer<T> action) {
return thenAcceptAsync(future, action, null);
}
/**
* 异步处理异常
*
* @param future CompletableFuture对象
* @param handler 异常处理函数
* @param executor 执行器
* @param <T> 结果类型
* @return CompletableFuture对象
*/
public static <T> CompletableFuture<T> exceptionallyAsync(
CompletableFuture<T> future,
Function<Throwable, T> handler,
Executor executor) {
return future.exceptionallyAsync(handler, executor != null ? executor : DEFAULT_EXECUTOR);
}
/**
* 使用默认执行器异步处理异常
*
* @param future CompletableFuture对象
* @param handler 异常处理函数
* @param <T> 结果类型
* @return CompletableFuture对象
*/
public static <T> CompletableFuture<T> exceptionallyAsync(
CompletableFuture<T> future,
Function<Throwable, T> handler) {
return exceptionallyAsync(future, handler, null);
}
/**
* 异步处理完成事件（无论成功或异常）
*
* @param future CompletableFuture对象
* @param action 完成动作
* @param executor 执行器
* @param <T> 结果类型
* @return CompletableFuture对象
*/
public static <T> CompletableFuture<T> whenCompleteAsync(
CompletableFuture<T> future,
BiConsumer<T, Throwable> action,
Executor executor) {
return future.whenCompleteAsync(action, executor != null ? executor : DEFAULT_EXECUTOR);
}
/**
* 使用默认执行器异步处理完成事件
*
* @param future CompletableFuture对象
* @param action 完成动作
* @param <T> 结果类型
* @return CompletableFuture对象
*/
public static <T> CompletableFuture<T> whenCompleteAsync(
CompletableFuture<T> future,
BiConsumer<T, Throwable> action) {
return whenCompleteAsync(future, action, null);
}
/**
* 设置CompletableFuture超时
*
* @param future CompletableFuture对象
* @param timeout 超时时间
* @param timeUnit 时间单位
* @param defaultValue 超时默认值
* @param <T> 结果类型
* @return 设置了超时的CompletableFuture
*/
public static <T> CompletableFuture<T> orTimeout(
CompletableFuture<T> future,
long timeout,
TimeUnit timeUnit,
T defaultValue) {
return future.orTimeout(timeout, timeUnit)
.exceptionally(ex -> {
if (ex instanceof TimeoutException) {
return defaultValue;
}
throw new CompletionException(ex);
});
}
/**
* 设置CompletableFuture超时（Java 9+）
*
* @param future CompletableFuture对象
* @param timeout 超时时间
* @param timeUnit 时间单位
* @param <T> 结果类型
* @return 设置了超时的CompletableFuture
*/
public static <T> CompletableFuture<T> orTimeout(
CompletableFuture<T> future,
long timeout,
TimeUnit timeUnit) {
return future.orTimeout(timeout, timeUnit);
}
/**
* 设置CompletableFuture超时（使用Duration）
*
* @param future CompletableFuture对象
* @param duration 超时时间
* @param <T> 结果类型
* @return 设置了超时的CompletableFuture
*/
public static <T> CompletableFuture<T> orTimeout(
CompletableFuture<T> future,
Duration duration) {
return future.orTimeout(duration.toMillis(), TimeUnit.MILLISECONDS);
}
/**
* 批量执行任务并收集结果，支持并行度控制
*
* @param tasks 任务列表
* @param parallelism 并行度
* @param executor 执行器
* @param <T> 结果类型
* @return 所有任务的结果列表
*/
public static <T> List<T> executeBatch(
List<Supplier<T>> tasks,
int parallelism,
Executor executor) {
final Executor actualExecutor = executor != null ? executor : DEFAULT_EXECUTOR;
return tasks.stream()
.collect(Collectors.groupingBy(t -> tasks.indexOf(t) / parallelism))
.values().stream()
.flatMap(batch -> {
List<CompletableFuture<T>> futures = batch.stream()
.map(task -> CompletableFuture.supplyAsync(task, actualExecutor))
.collect(Collectors.toList());
CompletableFuture<Void> allFutures = CompletableFuture.allOf(
futures.toArray(new CompletableFuture[0]));
// 等待当前批次完成
allFutures.join();
return futures.stream().map(CompletableFuture::join);
})
.collect(Collectors.toList());
}
/**
* 使用默认执行器批量执行任务并收集结果，支持并行度控制
*
* @param tasks 任务列表
* @param parallelism 并行度
* @param <T> 结果类型
* @return 所有任务的结果列表
*/
public static <T> List<T> executeBatch(List<Supplier<T>> tasks, int parallelism) {
return executeBatch(tasks, parallelism, null);
}
}
