Java并发编程：CountDownLatch和Semaphore的实战案例

原创川长思鸟来 2024-11-07 00:51 10阅读 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();
 }

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);
} 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 int permits =2; //同时允许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`用于控制对资源的并发访问。这两个工具类在并发编程中非常有用，可以帮助我们更好地管理线程间的协作和资源的同步访问。