Java并发编程：CountDownLatch和Semaphore的应用示例

原创ゝ一纸荒年。 2024-11-30 08:03 0阅读 0赞

CountDownLatch 和 Semaphore 是 Java 中两种常用的并发工具，它们主要用于控制多个线程的执行顺序和相互依赖关系。以下分别提供这两个工具的应用示例。

1. CountDownLatch 示例：

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

public class CountDownLatchExample {
    private CountDownLatch countDownLatch;
    private int threadCount = 5; // 指定并发线程数

public CountDownLatchExample() {
        countDownLatch = new CountDownLatch(threadCount);
    }

public void startThreads() throws InterruptedException {
        for (int i = 0; i < threadCount; i++) {
            Thread thread = new Thread(() -> {
                try {
                    // 在这里执行线程需要的代码
                    countDownLatch.countDown(); // 当前线程完成任务后，计数器会减少1
                } catch (Exception e) {
                    System.out.println("Thread " + i + " caught an exception: " + e);
                }
            }));
            thread.start();
        }
    }

public static void main(String[] args) throws InterruptedException {
        CountDownLatchExample example = new CountDownLatchExample();
        example.startThreads(); // 启动线程
        example.countDownLatch.await(); // 等待计数器为0，表示所有线程已完成任务
        System.out.println("All threads have completed their tasks.");
    }
}
```

2. Semaphore 示例：

Semaphore 主要用于控制同时访问特定资源的线程数量。以下是一个简单的示例：

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

public class SemaphoreExample {
    private Semaphore semaphore; // 创建信号量
    private int permits = 5; // 初始允许的并发线程数

public SemaphoreExample() {
        semaphore = new Semaphore(permits);
    }

public void allowThreads(int threadCount) throws InterruptedException {
        for (int i = 0; i < threadCount; i++) {
            Thread thread = new Thread(() -> {
                try {
                    // 线程需要获取资源，先尝试获取信号量
                    semaphore.acquire(); // 如果没有足够的许可（即 permits < 0），则会阻塞直到有许可可用

// 当获得许可后，执行任务
                    // 这里可以替换为任何实际的线程操作
                    System.out.println("Thread " + i + " acquired permit. Proceeding...");
                } catch (Exception e) {
                    System.out.println("Thread " + i + " caught an exception: " + e);
                }
            }));
            thread.start();
        }
    }

public static void main(String[] args) throws InterruptedException {
        SemaphoreExample example = new SemaphoreExample();
        example.allowThreads(10); // 启动允许线程的循环
        example.semaphore.release(); // 释放信号量，让其他线程有机会获取资源
        example.countDownLatch.await(); // 等待所有线程执行完毕

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

以上示例分别展示了CountDownLatch 和 Semaphore 在并发控制中的应用。