Java并发工具：CountDownLatch、Semaphore的应用示例及问题

原创向右看齐 2024-10-31 18:39 29阅读 0赞

Java并发工具类是`java.util.concurrent`包的一部分，它们提供了一些高级工具来帮助开发者处理并发问题。`CountDownLatch`和`Semaphore`是其中的两个工具，它们各自有不同的用途和应用场景。

### CountDownLatch`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 }
 }
 }
}
```**问题：**
- `CountDownLatch`一旦计数减到0，就不能再被重置。如果需要重复使用，可以考虑使用`CyclicBarrier`。
-必须确保在所有任务完成后调用`countDown()`，否则主线程会无限期等待。

### Semaphore`Semaphore`是一个计数信号量，它用于限制对资源的访问数量。

**应用示例：**

假设我们有一个资源池，需要限制同时访问该资源的线程数量。

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

public class SemaphoreExample {
 public static void main(String[] args) {
 final int permits =3; //同时允许的最大访问数 final Semaphore semaphore = new Semaphore(permits);

for (int i =0; i <6; 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); //模拟资源访问时间} catch (InterruptedException e) {
e.printStackTrace();
} finally {
 semaphore.release(); //释放许可 System.out.println(Thread.currentThread().getName() + "释放资源");
 }
 }
 }
}
```**问题：**
-必须确保在访问资源后释放许可，否则可能导致死锁。
- `Semaphore`的公平性问题：默认情况下，`Semaphore`是非公平的，可能导致某些线程饥饿。可以通过构造函数传入`true`来创建一个公平的`Semaphore`。

这些工具的正确使用可以帮助开发者更好地管理并发，但同时也需要注意它们可能引入的问题。