Java并发工具类：CountDownLatch、Semaphore和CyclicBarrier使用示例

原创 Myth丶恋晨 2024-11-24 03:30 5阅读 0赞

1. CountDownLatch：
CountDownLatch是一个同步工具，它有一个特定的计数值。当一个线程等待某个条件满足时（如所有子任务完成），可以调用`countDown()`方法来减少计数值。

示例：
```java
import java.util.concurrent.CountDownLatch;

public class CounterExample {
    private CountDownLatch countDownLatch;

public CounterExample(int count) {
        countDownLatch = new CountDownLatch(count);
    }

public void task(int index) throws InterruptedException {
        System.out.println("Task " + index + " started");
        countDownLatch.countDown();
        System.out.println("Task " + index + " finished");
    }

public static void main(String[] args) {
        CounterExample counter = new CounterExample(3);

for (int i = 0; i < 3; i++) {
            new Thread(() -> counter.task(i)).start();
        }

// 等待所有任务完成
        countDownLatch.await();

System.out.println("All tasks completed");
    }
}
```
2. Semaphore：
Semaphore是一种线程同步工具，它类似于锁，但更灵活。Semaphore的主要作用是限制同时访问资源的线程数量。

示例：
```java
import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    private Semaphore semaphore;

public SemaphoreExample(int permits) {
        semaphore = new Semaphore(permits);
    }

// 线程访问资源，需要获得许可
    public void task() throws InterruptedException {
        semaphore.acquire();
        System.out.println("Task started");
        // ... 其他任务代码
        System.out.println("Task finished");
        semaphore.release();
    }

public static void main(String[] args) {
        SemaphoreExample semaphoreExample = new SemaphoreExample(2);

for (int i = 0; i < 3; i++) {
            new Thread(() -> semaphoreExample.task()).start();
        }

// 等待所有任务完成
        semaphoreExample.semaphore.acquireUninterruptibly(); // 注意这里，需要调用acquireUninterruptibly()方法

System.out.println("All tasks completed");
    }
}
```
3. CyclicBarrier：
CyclicBarrier是Java并发工具类中的一个线程同步对象。当CyclicBarrier的计数达到某个值时（通常为初始值），所有等待该条件的线程都会被唤醒，然后按照它们加入循环的顺序执行。

示例：
```java
import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierExample {
    private CyclicBarrier cyclicBarrier;

public CyclicBarrierExample(int count) {
        cyclicBarrier = new CyclicBarrier(count);
    }

// 线程进入屏障等待，计数到达1时唤醒所有线程
    public void task() throws InterruptedException {
        try {
            cyclicBarrier.await();
            System.out.println("Task started");
            // ... 其他任务代码
            System.out.println("Task finished");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

public static void main(String[] args) {
        CyclicBarrierExample barrier = new CyclicBarrierExample(2);

for (int i = 0; i < 3; i++) {
            new Thread(() -> barrier.task()).start();
        }

// 等待所有任务完成
        barrier.cyclicBarrier.await();

System.out.println("All tasks completed");
    }
}
```
以上三个示例展示了CountDownLatch、Semaphore和CyclicBarrier在Java并发编程中的使用。