转自https://mp.weixin.qq.com/s/p1nwmRl6-dyThqJ6StxC-A
在Java应用开发中,为了提升系统性能和响应速度,我们经常需要将一些耗时操作(如调用外部API、查询数据库、复杂计算等)进行异步并行处理。当主流程需要等待所有这些并行任务执行完毕后再继续时,我们通常会用到 ExecutorService
、 CountDownLatch
等并发工具。
然而,直接使用这些原生工具,往往意味着需要编写一些重复的、模式化的“胶水代码”,这不仅增加了代码量,也让核心业务逻辑显得不够清晰。
为了解决这个问题,我封装了一个名为 LatchUtils
的轻量级工具类。它能够以一种极其简洁的方式来组织和管理这一类异步任务。
详细代码
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executor;
import java.util.concurrent.TimeUnit;public class LatchUtils { private static final ThreadLocal<List<TaskInfo>> THREADLOCAL = ThreadLocal.withInitial(LinkedList::new); public static void submitTask(Executor executor, Runnable runnable) {
THREADLOCAL.get().add(new TaskInfo(executor, runnable));
} private static List<TaskInfo> popTask() {
List<TaskInfo> taskInfos = THREADLOCAL.get();
THREADLOCAL.remove();
return taskInfos;
} public static boolean waitFor(long timeout, TimeUnit timeUnit) {
List<TaskInfo> taskInfos = popTask();
if (taskInfos.isEmpty()) {
return true;
}
CountDownLatch latch = new CountDownLatch(taskInfos.size());
for (TaskInfo taskInfo : taskInfos) {
Executor executor = taskInfo.executor;
Runnable runnable = taskInfo.runnable;
executor.execute(() -> {
try {
runnable.run();
} finally {
latch.countDown();
}
});
}
boolean await = false;
try {
await = latch.await(timeout, timeUnit);
} catch (Exception ignored) {
}
return await;
} private static final class TaskInfo {
private final Executor executor;
private final Runnable runnable; public TaskInfo(Executor executor, Runnable runnable) {
this.executor = executor;
this.runnable = runnable;
}
}
}
核心思想
LatchUtils
的设计哲学是:多次提交,一次等待。
- 任务注册: 在主流程代码中,可以先通过
LatchUtils.submitTask()
提交Runnable任务和其对应的Executor(该线程池用来执行这个Runnable)。 - 执行并等待: 当并行任务都提交完毕后,你只需调用一次
LatchUtils.waitFor()
。该方法会立即触发所有已注册任务的执行,并阻塞等待所有任务执行完成或超时。
API概览
这个工具类对外暴露的接口极其简单,只有两个核心静态方法:
submitTask()
public static void submitTask(Executor executor, Runnable runnable)
功能: 提交一个异步任务。
参数:
- executor: java.util.concurrent.Executor - 指定执行此任务的线程池。
- runnable: java.lang.Runnable - 需要异步执行的具体业务逻辑。
waitFor()
public static boolean waitFor(long timeout, TimeUnit timeUnit)
功能: 触发所有已提交任务的执行,并同步等待它们全部完成。
参数:
- timeout: long - 最长等待时间。
- timeUnit: java.util.concurrent.TimeUnit - 等待时间单位。
返回值:
- true: 如果所有任务在指定时间内成功完成。
- false: 如果等待超时。
注意: 该方法在执行后会自动清理当前线程提交的任务列表,因此可以重复使用。
实战实例
让我们来看一个典型的应用场景:一个聚合服务需要同时调用用户服务、订单服务和商品服务,拿到所有结果后再进行下一步处理。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;public class Main { public static void main(String[] args) {
// 1. 准备一个线程池
ExecutorService executorService = Executors.newFixedThreadPool(3); System.out.println("主流程开始,准备分发异步任务..."); // 2. 提交多个异步任务
// 任务一:获取用户信息
LatchUtils.submitTask(executorService, () -> {
try {
System.out.println("开始获取用户信息...");
Thread.sleep(1000); // 模拟耗时
System.out.println("获取用户信息成功!");
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}); // 任务二:获取订单信息
LatchUtils.submitTask(executorService, () -> {
try {
System.out.println("开始获取订单信息...");
Thread.sleep(1500); // 模拟耗时
System.out.println("获取订单信息成功!");
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}); // 任务三:获取商品信息
LatchUtils.submitTask(executorService, () -> {
try {
System.out.println("开始获取商品信息...");
Thread.sleep(500); // 模拟耗时
System.out.println("获取商品信息成功!");
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}); System.out.println("所有异步任务已提交,主线程开始等待..."); // 3. 等待所有任务完成,最长等待5秒
boolean allTasksCompleted = LatchUtils.waitFor(5, TimeUnit.SECONDS); // 4. 根据等待结果继续主流程
if (allTasksCompleted) {
System.out.println("所有异步任务执行成功,主流程继续...");
} else {
System.err.println("有任务执行超时,主流程中断!");
} // 5. 关闭线程池
executorService.shutdown();
}
}
输出结果:
主流程开始,准备分发异步任务...
所有异步任务已提交,主线程开始等待...
开始获取商品信息...
开始获取用户信息...
开始获取订单信息...
获取商品信息成功!
获取用户信息成功!
获取订单信息成功!
所有异步任务执行成功,主流程继续...
从这个例子中可以看到,业务代码变得非常清晰。我们只需要关注“提交任务”和“等待结果”这两个动作,而无需关心 CountDownLatch 的初始化、countDown() 的调用以及异常处理等细节。