Java并发实战：CountDownLatch和Semaphore在协调多个线程中的应用实例

原创怼烎@ 2024-11-13 23:55 6阅读 0赞

在Java中，`CountDownLatch`和`Semaphore`是两个非常有用的同步工具，它们可以帮助开发者协调多个线程的执行。下面我将分别给出`CountDownLatch`和`Semaphore`的应用实例。

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

**场景**：假设我们有一个主线程需要等待三个工作线程完成各自的任务后才能继续执行。

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

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

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

try {
 latch.await(); //等待所有线程完成 System.out.println("所有工作线程已完成");
} catch (InterruptedException e) {
e.printStackTrace();
 }
 }

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); //模拟耗时操作} catch (InterruptedException e) {
e.printStackTrace();
} finally {
 latch.countDown(); //任务完成，计数减1 }
 }
 }
}
```### Semaphore应用实例`Semaphore`是一个计数信号量，它用于限制对资源的访问数量。

**场景**：假设我们有五个线程需要访问同一个资源，但同时只能有两个线程访问。

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

public class SemaphoreExample {
 public static void main(String[] args) {
 final int permits =2; //同时允许访问资源的线程数 final Semaphore semaphore = new Semaphore(permits);

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(); // 请求一个许可 try {
//模拟访问资源 System.out.println(Thread.currentThread().getName() + "正在访问资源");
Thread.sleep(1000); //模拟耗时操作} finally {
 semaphore.release(); //释放许可 System.out.println(Thread.currentThread().getName() + "释放资源");
 }
} catch (InterruptedException e) {
e.printStackTrace();
 }
 }
 }
}
```在这两个实例中，`CountDownLatch`用于确保主线程等待所有工作线程完成后再继续执行，而`Semaphore`用于控制对共享资源的并发访问。这两个工具在多线程编程中非常有用，可以帮助开发者实现复杂的线程同步和协调。