Java并发工具类（如Semaphore和CountDownLatch）使用案例

原创怼烎@ 2024-12-05 22:51 116阅读 0赞

在Java中，`Semaphore`和`CountDownLatch`是常用的并发工具类。它们分别用于控制多个线程对共享资源的访问，并协调多线程的执行顺序。

以下是这两种工具类使用案例的简单示例：

1. **Semaphore**（信号量）：

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

public class SemaphoreExample {
    private final Semaphore permit = new Semaphore(2);

public void doTask() throws InterruptedException {
        permit.acquire(); // 获取一个许可证，最多只能有两个任务同时执行

System.out.println("Task 1 is executing...");

// 进行任务的逻辑处理
        Thread.sleep(3000); // 模拟耗时操作

System.out.println("Task 1 completed...");

permit.release(); // 释放一个许可证，允许其他任务获取许可证进行执行
    }

public static void main(String[] args) {
        SemaphoreExample example = new SemaphoreExample();
        new Thread(example::doTask).start(); // 创建并启动一个新的线程来执行任务
    }
}
```

在这个例子中，我们创建了一个`Semaphore`实例，其初始许可数为2。`doTask`方法会尝试获取许可证进行任务执行。

2. **CountDownLatch**（计数器）：

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

public class CountDownLatchExample {
    private final CountDownLatch countDown = new CountDownLatch(3);

public void doTask() {
        System.out.println("Task 2 is starting...");

try {
            countDown.await(); // 等待计数器为0，表示前一个任务已经完成
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

System.out.println("Task 2 completed...");

// 在这里进行你的任务逻辑处理
    }

public static void main(String[] args) {
        CountDownLatchExample example = new CountDownLatchExample();
        new Thread(example::doTask).start(); // 创建并启动一个新的线程来执行任务

// 这里创建一个计数器，当所有任务完成后，计数器的值将变为0
        final CountDownLatch allTasksDone = new CountDownLatch(1);
        new Thread(() -> {
            try {
                allTasksDone.await(); // 等待直到计数器为0，表示前一个任务已经完成
                System.out.println("All tasks completed..."); // 所有任务完成后，这里输出一条消息
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        })).start(); // 创建并启动一个新的线程来执行辅助任务，当所有任务完成时，计数器的值将变为0

// 这里可以添加一个方法来检查是否所有任务已经完成
    public boolean areAllTasksDone() throws InterruptedException {
        return allTasksDone.await(1, TimeUnit.SECONDS)); // 等待直到计数器为0或者超时时间到达，表示前一个任务已经完成
    }
}
```

在这个例子中，我们创建了一个`CountDownLatch`实例，初始值为3。每个任务执行完成后，会调用`countDown.countDown()`来减少计数器的值。

当所有任务（三个任务）完成后，计数器的值将变为0，这时候主线程就可以通过检查`areAllTasksDone()`方法返回的结果来确定是否所有任务已经完成。