Java并发工具类：CountDownLatch，Semaphore的应用实例

原创小灰灰 2024-12-08 18:03 18阅读 0赞

CountDownLatch和Semaphore都是Java中常用的并发工具类，它们在多线程场景中发挥着重要的角色。下面我会分别给出这两个工具类的应用实例。

1. CountDownLatch

CountDownLatch用于控制一个或多个线程的执行。当它的计数器为0时，所有等待它的线程都将被释放并执行后续操作。

应用实例：

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

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

public void startThread() {
        new Thread(() -> {
            try {
                countDownLatch.await(1000, TimeUnit.MILLISECONDS)); // 如果线程没有在1秒内被释放，将会抛出InterruptedException
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } finally {
                System.out.println("Thread " + Thread.currentThread().getName() + " completed after waiting for signal.");
                countDownLatch.countDown(); // 通知CountDownLatch剩余的任务已完成
            }
        })).start();
    }

public static void main(String[] args) throws InterruptedException {
        CounterExample example = new CounterExample();

example.startThread();

// 等待所有线程执行完毕
        example.countDownLatch.await();

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

2. Semaphore

Semaphore是一种多路共享资源的工具。它具有两个基本操作：acquire()（获取信号）和release()（释放信号）。

应用实例：

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

public class SemaphoreExample {
    private final Semaphore semaphore = new Semaphore(3); // 创建一个允许3个并发访问的Semaphore

public void startThread() throws InterruptedException {
        for (int i = 0; i < 5; i++) { // 这里模拟了5个线程
            if (semaphore.tryAcquire()) { // 如果信号可用，尝试获取它
                System.out.println("Thread " + Thread.currentThread().getName() + " acquired semaphore and proceeding.");
                doSomeTask(); // 假设这里有一个任务需要完成
            } else {
                System.out.println("Semaphore is full. Thread " + Thread.currentThread().getName() + " waiting for signal to acquire.");
                break; // 如果信号已满，线程将等待信号释放后再尝试获取
            }
        }
    }

private void doSomeTask() { // 这里只是一个任务的模拟，可以替换成实际操作
        System.out.println("Thread " + Thread.currentThread().getName() + " completed task.");
        semaphore.release(); // 信号已释放，允许其他线程尝试获取它
    }

public static void main(String[] args) throws InterruptedException {
        SemaphoreExample example = new SemaphoreExample();

example.startThread();

// 等待所有线程执行完毕
        Thread.sleep(1000); // 这里模拟了线程执行时间，可以根据实际情况调整

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

以上实例中，CountDownLatch用于控制线程的等待和释放，Semaphore则用于控制多个线程对共享资源的访问。