详解Java并发：CountDownLatch和Semaphore的实战案例？

原创不念不忘少年蓝@ 2024-11-23 20:21 21阅读 0赞

`CountDownLatch`和`Semaphore`是Java并发工具库中的两个重要类，主要用于资源管理和线程协调。

1. CountDownLatch

当一个计数器的值为0时，所有等待该计数器的线程都将被唤醒。这在需要某个任务完成或多个任务顺序执行的场景中非常有用。

实战案例：
```java
// 创建CountDownLatch对象，初始值为3
CountDownLatch countDownLatch = new CountDownLatch(3);

// 这三个线程将共享countDownLatch对象，当它们调用countDown方法时，会减少该计数器的值。
Thread thread1 = new Thread(() -> {
    try {
        countDownLatch.countDown();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
});
Thread thread2 = new Thread(() -> {
    try {
        countDownLatch.countDown();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
});
Thread thread3 = new Thread(() -> {
    try {
        countDownLatch.countDown();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
});

// 启动线程
thread1.start();
thread2.start();
thread3.start();

// 等待所有计数器都被消耗掉
countDownLatch.await();

System.out.println("CountDownLatch reached zero, all threads have completed their tasks.");

```
在这个例子中，三个线程共享一个`CountDownLatch`。当每个线程调用`countDown()`方法时，计数器会减1，直到所有线程都完成了他们的任务（即调用了`await()`），`CountDownLatch`的值才会变为0。

2. Semaphore

`Semaphore`是Java并发工具库中的一种信号量，它用于控制同时访问共享资源的最大数量。当资源可用时， semaphore 的计数器会加1；反之，当资源不足时， semaphore 会阻塞所有请求资源的线程，直到计数器减1到0，表示资源已释放。

实战案例：
```java
import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    private final Semaphore semaphore = new Semaphore(2); // 创建一个可并发访问的最大为2的信号量

public void accessResource() throws InterruptedException {
        try {
            semaphore.acquire(); // 请求资源，如果当前资源数小于或等于0，则会阻塞
            System.out.println("Resource available for access!"); // 资源可用，执行操作
            Thread.sleep(3000); // 模拟耗时操作
        } finally {
            try {
                semaphore.release(); // 释放资源，当前资源数加1
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

public static void main(String[] args) {
        SemaphoreExample example = new SemaphoreExample();
        Thread thread1 = new Thread(() -> {
            try {
                example.accessResource();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread 1 completed its task.");
            // 模拟耗时操作，以让主线程有机会执行
            Thread.sleep(5000);
            System.out.println("Thread 1 woke up after simulated delay.");
            }
        catch (Exception e) {
            e.printStackTrace();
        }
        })); // 创建并启动线程

// 等待所有线程完成任务
    System.out.println("Main thread waiting for all threads to complete tasks...");
    try {
        Thread.join(thread1); // 主线程等待子线程结束
        System.out.println("All threads completed their tasks.");
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}
```
在这个例子中，我们创建了一个`Semaphore`实例，它的初始许可数为2。当一个线程试图获取资源（调用`semaphore.acquire()`）但当前资源已达到最大（2），这个请求将被阻塞，直到有其他线程释放了资源。

在`main`方法中，我们创建了两个线程：`thread1` 和 `thread2`。`thread1` 调用`accessResource()`方法尝试获取资源，由于资源已满，会被阻塞。而`thread2` 先于`thread1`释放了资源，因此`thread1`能够成功获取资源并执行后续操作。

这个例子展示了如何使用`Semaphore`来控制对共享资源的访问，确保在任何时候不超过一定的并发数量。