Java并发编程：Semaphore与CountDownLatch的应用实例

原创约定不等于承诺〃 2024-09-29 11:54 70阅读 0赞

Semaphore和CountDownLatch都是Java中用于管理并发的重要工具。这里我们将通过两个实际的例子来理解和使用它们。

1. Semaphore（信号量）示例

假设我们有一个生产者，多个消费者，而且资源是有限的，比如一个库存。我们可以使用Semaphore来控制最多同时有多少个消费者在请求库存。

```java
import java.util.concurrent.Semaphore;

public class Stock {
    private final Semaphore stock = new Semaphore(10); // 限制库存最多10

public void produce() throws InterruptedException {
        // 假设生产者生产了5件商品
        for (int i = 0; i < 5; i++) {
            stock.acquire(); // 请求库存，如果库存不足则阻塞
            System.out.println("Producer: Stock " + i + " taken"); // 生产者拿走了某个商品
            stock.release(); // 返还库存，如果库存充足则自动释放
        }
    }

public void consume() throws InterruptedException {
        for (int i = 0; i < 5; i++) { // 假设消费者消费了5件商品
            stock.acquire(); // 请求库存，如果库存不足则阻塞
            System.out.println("Consumer: Stock " + i + " taken"); // 消费者拿走了某个商品
            stock.release(); // 返还库存，如果库存充足则自动释放
        }
    }

public void main(String[] args) throws InterruptedException {
        Thread producer = new Thread(new Producer());
        Thread consumer1 = new Thread(new Consumer(1)));
        Thread consumer2 = new Thread(new Consumer(2)));

producer.start();
        consumer1.start();
        consumer2.start();

producer.join();
        consumer1.join();
        consumer2.join();

System.out.println("Stock is empty: " + stock.isEmpty())); // 检查库存是否为空
    }
}
```

通过这个例子，我们可以看到Semaphore如何帮助我们管理并发和资源。

2. CountDownLatch（计数down latch）示例

CountDownLatch用于协调一组相关线程的执行。当我们创建一个CountDownLatch并初始化为初始值后，每当有一个任务完成时，就将count减1。当count减少到0时，CountDownLatch会调用所有等待它的线程的run方法。

下面是一个使用CountDownLatch的简单示例：

```java
import java.util.concurrent.CountDownLatch;

public class Counter {
    private final CountDownLatch countDownLatch = new CountDownLatch(3);

public void task1() {
        try {
            System.out.println("Task 1 started");
            countDownLatch.await(); // 等待count到达0，表示所有任务都完成了
            System.out.println("Task 1 completed");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

public void task2() {
        try {
            System.out.println("Task 2 started");
            countDownLatch.countDown(); // 当计数器到达0时，调用countDownLatch的await方法
            System.out.println("Task 2 completed");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

public void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new Task1());
        Thread t2 = new Thread(new Task2());

t1.start(); // 启动任务1
        t2.start(); // 启动任务2

t1.join(); // 等待任务1执行完成
        t2.join(); // 等待任务2执行完成

System.out.println("All tasks completed");
    }
}
```

在这个例子中，我们创建了两个任务（task1和task2），每个任务都会调用countDownLatch的await方法。当所有任务都完成后，countDownLatch的count会减为0。

这就是CountDownLatch在Java并发编程中的应用实例。