LatchUtils：简化Java异步任务同步的利器

转自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() 的调用以及异常处理等细节。