Java线程协调技巧：Semaphore与CountDownLatch应用

在Java并发编程中，Semaphore和CountDownLatch是java.util.concurrent包中两个轻量高效、语义清晰的线程协调利器：前者像智能停车场管理员，通过许可机制精准控制同时访问资源的线程数量（如限制5个数据库连接），避免资源过载；后者则像任务指挥官，让主线程优雅等待多个子任务全部完成后再继续执行，无需轮询或复杂锁逻辑。二者虽用途迥异——一个重在“限流”，一个重在“同步等待”——却共同以简洁API大幅降低并发编程门槛，配合ExecutorService更能发挥协同优势，是构建健壮、可维护高并发应用不可或缺的核心工具。

在Java并发编程中，Semaphore和CountDownLatch是两个常用的线程协调工具，它们属于java.util.concurrent包中的同步辅助类。虽然功能不同，但都能有效控制多个线程之间的协作行为。

Semaphore：控制并发访问资源的数量

Semaphore（信号量）用于限制同时访问某一资源的线程数量，适合实现资源池，如数据库连接池、线程池等。

它通过维护一组许可（permits）来实现控制：

• 调用acquire()方法时，线程尝试获取一个许可，如果没有可用许可，线程将被阻塞。
• 调用release()方法时，线程释放一个许可，唤醒等待的线程。

import java.util.concurrent.Semaphore;
<p>public class ParkingLot {
private static final int CAPACITY = 5;
private Semaphore semaphore = new Semaphore(CAPACITY);</p><pre class="brush:java;toolbar:false;">public void park(String carName) throws InterruptedException {
    semaphore.acquire(); // 获取一个停车位
    System.out.println(carName + " 停车成功");

    // 模拟停车一段时间
    Thread.sleep(2000);

    System.out.println(carName + " 离开停车场");
    semaphore.release(); // 释放停车位
}

public static void main(String[] args) {
    ParkingLot lot = new ParkingLot();
    for (int i = 1; i <= 8; i++) {
        new Thread(() -> {
            try {
                lot.park(Thread.currentThread().getName());
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }, "Car-" + i).start();
    }
}

}

在这个例子中，最多只有5个线程能同时执行park操作，其余线程会等待，直到有车离开释放许可。

CountDownLatch：等待一组操作完成

CountDownLatch允许一个或多个线程等待其他线程完成一系列操作。它通过一个计数器实现：

• 计数器初始化为某个正整数，表示需要等待的事件数量。
• 调用await()的线程会被阻塞，直到计数器变为0。
• 每次调用countDown()，计数器减1。

import java.util.concurrent.CountDownLatch;
<p>public class TaskRunner {
public static void main(String[] args) throws InterruptedException {
int taskCount = 3;
CountDownLatch latch = new CountDownLatch(taskCount);</p><pre class="brush:java;toolbar:false;">    for (int i = 1; i <= taskCount; i++) {
        final int taskId = i;
        new Thread(() -> {
            System.out.println("任务 " + taskId + " 开始执行");
            try {
                Thread.sleep(1000 * taskId); // 模拟不同耗时
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            System.out.println("任务 " + taskId + " 完成");
            latch.countDown(); // 计数减1
        }).start();
    }

    System.out.println("等待所有任务完成...");
    latch.await(); // 阻塞直到计数为0
    System.out.println("所有任务已完成，主线程继续执行");
}

}

主线程调用await()后暂停，直到三个子线程各自调用countDown()使计数归零，才继续执行。

使用建议与注意事项

• Semaphore适用于控制资源的并发访问量，注意及时调用release()避免死锁或资源泄露。
• CountDownLatch是一次性的，计数器不能重置。如果需要重复使用，考虑CyclicBarrier。
• 两者都不需要像synchronized那样显式加锁，API更简洁，适合特定场景下的线程协调。
• 结合ExecutorService使用效果更佳，可以更好地管理线程生命周期。

基本上就这些。根据具体需求选择合适的工具，Semaphore侧重“限流”，CountDownLatch侧重“等待完成”，合理使用能大大简化并发控制逻辑。

今天关于《Java线程协调技巧：Semaphore与CountDownLatch应用》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于的内容请关注golang学习网公众号！