Java并发编程中CountDownLatch、Semaphore的区别和实例

原创青旅半醒 2024-11-08 09:54 1阅读 0赞

在Java并发编程中，`CountDownLatch`和`Semaphore`都是同步辅助类，用于控制多个线程之间的执行顺序，但它们的用途和工作方式有所不同。

### CountDownLatch`CountDownLatch`是一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。

- **用途**：用于一个或多个线程等待一组操作在其他线程中完成。
- **工作方式**：通过一个计数器来实现，计数器的初始值是操作的数量。每当一个操作完成时，计数器的值就会减少1，当计数器的值达到0时，等待的线程会被唤醒。

**实例**：

```javaimport java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {
 public static void main(String[] args) throws InterruptedException {
 final int totalThreads =3;
CountDownLatch latch = new CountDownLatch(totalThreads);

for (int i =0; i < totalThreads; i++) {
 new Thread(new Worker(latch)).start();
 }

latch.await(); //等待所有线程完成 System.out.println("所有任务完成");
 }

static class Worker implements Runnable {
 private final CountDownLatch latch;

public Worker(CountDownLatch latch) {
 this.latch = latch;
 }

@Override public void run() {
 try {
 System.out.println(Thread.currentThread().getName() + "正在执行任务");
//模拟任务执行时间Thread.sleep(1000);
 System.out.println(Thread.currentThread().getName() + "任务完成");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
 latch.countDown(); //任务完成，计数器减1 }
 }
 }
}
```### Semaphore`Semaphore`是一个计数信号量，用于限制对资源的访问，它维护了一组许可证，每个`acquire()`调用会获取一个许可证，每个`release()`调用会释放一个许可证。

- **用途**：用于限制对资源的访问数量，控制同时访问资源的线程数量。
- **工作方式**：通过一个计数器来控制对资源的访问，计数器的值表示可用的许可证数量。当线程需要访问资源时，它必须先获取一个许可证，如果许可证不足，则线程会阻塞，直到有许可证可用。

**实例**：

```javaimport java.util.concurrent.Semaphore;

public class SemaphoreExample {
 public static void main(String[] args) {
 final Semaphore semaphore = new Semaphore(2); //同时只允许2个线程访问资源 for (int i =0; i <5; i++) {
 new Thread(new Worker(semaphore)).start();
 }
 }

static class Worker implements Runnable {
 private final Semaphore semaphore;

public Worker(Semaphore semaphore) {
 this.semaphore = semaphore;
 }

@Override public void run() {
 try {
 semaphore.acquire(); // 获取一个许可证 System.out.println(Thread.currentThread().getName() + "正在访问资源");
//模拟资源访问时间Thread.sleep(1000);
 System.out.println(Thread.currentThread().getName() + "释放资源");
 semaphore.release(); //释放一个许可证} catch (InterruptedException e) {
e.printStackTrace();
 }
 }
 }
}
```在实际应用中，选择`CountDownLatch`还是`Semaphore`取决于具体的同步需求。`CountDownLatch`适用于等待一组操作完成的场景，而`Semaphore`适用于控制对资源的并发访问。