Java 并发神器：LatchUtils 一招搞定复杂异步同步！

最新推荐文章于 2025-11-04 10:02:19 发布

原创最新推荐文章于 2025-11-04 10:02:19 发布 · 634 阅读

14 ·

CC 4.0 BY-SA版权

文章标签：

#java #python #开发语言

在高并发系统中，简单往往意味着稳定。LatchUtils 并不是为了替代 JDK 的并发框架，而是为了在特定场景下，提供一种更符合直觉的方式来管理异步任务。

在现代 Java 应用开发中，并发几乎是提升性能的“标配”。无论是并行调用多个微服务接口、批量查询数据库，还是执行密集计算，我们都离不开异步与并行。

然而，当主线程需要等待多个异步任务完成后再继续执行时，开发者往往需要手动编写大量控制逻辑。例如使用 ExecutorService、CountDownLatch、CompletableFuture 等工具时，总会出现冗余的样板代码（如 latch.countDown()、异常处理、await 等）。

这些重复性逻辑不仅分散了业务重点，还让代码显得笨重。

于是，我们引入了一个轻量级的并发封装工具 —— LatchUtils。它秉持“多次提交，一次等待”的核心设计理念，让异步任务的管理变得极其简洁。

设计思想：多次提交，一次等待

LatchUtils 的核心思想是将任务注册与任务等待分离：

任务注册阶段：通过 submitTask() 方法注册多个任务及其对应线程池；
等待阶段：在所有任务提交完成后，调用一次 waitFor() 即可触发执行并同步等待。

简单来说，你只需要两步：

提交所有异步任务
等待全部执行完毕

而不需要再关心 CountDownLatch 的创建、计数或中断异常。

项目路径结构

复制

/src
 └── main
     └── java
         └── com
             └── icoderoad
                 └── utils
                     └── LatchUtils.java

核心代码实现

以下是经过优化的 LatchUtils 实现。相比传统写法，它自动管理任务生命周期，使用 ThreadLocal 确保任务隔离，让多线程调用更安全。

复制

package com.icoderoad.utils;


import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executor;
import java.util.concurrent.TimeUnit;


/**
 * LatchUtils - 轻量级异步任务协调工具
 * 核心设计：多次提交，一次等待。
 */
public class LatchUtils {


    // 使用 ThreadLocal 存储当前线程提交的任务列表，保证线程隔离
    private static final ThreadLocal<List<TaskInfo>> TASK_POOL = ThreadLocal.withInitial(LinkedList::new);


    /**
     * 提交异步任务
     * @param executor 指定线程池执行任务
     * @param runnable 任务逻辑
     */
    public static void submitTask(Executor executor, Runnable runnable) {
        TASK_POOL.get().add(new TaskInfo(executor, runnable));
    }


    // 获取并清空任务列表
    private static List<TaskInfo> popTask() {
        List<TaskInfo> taskInfos = TASK_POOL.get();
        TASK_POOL.remove();
        return taskInfos;
    }


    /**
     * 触发所有任务执行，并同步等待完成
     * @param timeout  最大等待时间
     * @param timeUnit 时间单位
     * @return 是否在超时前全部完成
     */
    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) {
            taskInfo.executor.execute(() -> {
                try {
                    taskInfo.runnable.run();
                } finally {
                    latch.countDown();
                }
            });
        }


        try {
            return latch.await(timeout, timeUnit);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return false;
        }
    }


    // 内部任务封装类
    private static final class TaskInfo {
        private final Executor executor;
        private final Runnable runnable;


        TaskInfo(Executor executor, Runnable runnable) {
            this.executor = executor;
            this.runnable = runnable;
        }
    }
}

API 使用说明

方法名	说明	参数	返回值
`submitTask(Executor, Runnable)`	注册一个异步任务	`executor`：执行线程池`runnable`：任务逻辑	无
`waitFor(long, TimeUnit)`	启动所有任务并等待完成	`timeout`：超时时间`timeUnit`：时间单位	`true` - 全部成功`false` - 超时

💡 调用 waitFor() 后，当前线程的任务列表会被自动清理，可安全重复使用。

实战演示：聚合并行任务的优雅写法

我们以一个聚合服务为例：主流程需要并行调用 用户服务、订单服务 和 商品服务，在它们全部完成后再继续。

复制

package com.icoderoad.demo;


import com.icoderoad.utils.LatchUtils;


import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;


public class Main {


    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(3);


        System.out.println("主流程开始，准备分发异步任务...");


        // 注册异步任务
        LatchUtils.submitTask(executorService, () -> {
            System.out.println("开始获取用户信息...");
            sleep(1000);
            System.out.println("获取用户信息成功！");
        });


        LatchUtils.submitTask(executorService, () -> {
            System.out.println("开始获取订单信息...");
            sleep(1500);
            System.out.println("获取订单信息成功！");
        });


        LatchUtils.submitTask(executorService, () -> {
            System.out.println("开始获取商品信息...");
            sleep(500);
            System.out.println("获取商品信息成功！");
        });


        System.out.println("所有异步任务已提交，主线程开始等待...");


        boolean allDone = LatchUtils.waitFor(5, TimeUnit.SECONDS);


        if (allDone) {
            System.out.println("所有任务执行完成，主流程继续...");
        } else {
            System.err.println("有任务执行超时，主流程中断！");
        }


        executorService.shutdown();
    }


    private static void sleep(long millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

运行结果：

复制

主流程开始，准备分发异步任务...
所有异步任务已提交，主线程开始等待...
开始获取商品信息...
开始获取用户信息...
开始获取订单信息...
获取商品信息成功！
获取用户信息成功！
获取订单信息成功！
所有任务执行完成，主流程继续...

传统写法对比

方式一：使用 CountDownLatch（手动控制）

开发者需要显式创建 CountDownLatch，在每个任务中调用 countDown()，并在主线程中调用 await()，代码冗长、易出错。

方式二：使用 CompletableFuture

语义上更现代，但仍需创建多个 Future 并组合等待，异常处理较繁琐。

特性	LatchUtils	CountDownLatch	CompletableFuture
代码简洁度	极高	中等	较高
状态管理	自动	手动	自动
异常处理	内部封装	开发者处理	多异常需捕获
学习曲线	低	中	中
关注点分离	优秀	一般	良好