理解并发控制工具：Java的Semaphore和CyclicBarrier实例

原创分手后的思念是犯贱 2024-11-08 17:21 15阅读 0赞

在Java中，`Semaphore`和`CyclicBarrier`是两种用于控制并发的工具，它们可以帮助开发者管理多个线程的执行顺序和同步。

### Semaphore（信号量）

`Semaphore`是一个计数信号量，用于控制对资源的访问。它通常用于限制对资源的并发访问数量，或者用于控制线程之间的执行顺序。

**Semaphore的基本用法：**

1. **初始化Semaphore**：创建一个`Semaphore`对象，并指定一个初始值，这个值表示可用的许可证数量。
2. **获取许可证**：通过调用`Semaphore`的`acquire()`方法来获取一个许可证。如果许可证不足，线程将被阻塞，直到有许可证可用。
3. **释放许可证**：通过调用`Semaphore`的`release()`方法来释放一个许可证，使得其他等待的线程可以继续执行。

**Semaphore实例代码：**

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

public class SemaphoreExample {
 private static final int THREAD_COUNT =5;
 private static final Semaphore semaphore = new Semaphore(3);

public static void main(String[] args) {
 for (int i =0; i < THREAD_COUNT; i++) {
 new Thread(new Worker()).start();
 }
 }

static class Worker implements Runnable {
@Override public void run() {
 try {
 semaphore.acquire(); // 获取许可证 System.out.println(Thread.currentThread().getName() + " is running.");
Thread.sleep(1000); //模拟工作 semaphore.release(); //释放许可证} catch (InterruptedException e) {
e.printStackTrace();
 }
 }
 }
}
```### CyclicBarrier（循环栅栏）

`CyclicBarrier`是一个同步辅助类，允许一组线程相互等待，直到所有线程都到达一个公共屏障点（barrier point）。当所有线程都到达屏障点时，它们可以继续执行。

**CyclicBarrier的基本用法：**

1. **初始化CyclicBarrier**：创建一个`CyclicBarrier`对象，并指定参与同步的线程数量。
2. **等待屏障**：每个线程在到达屏障点时调用`await()`方法。如果还有线程未到达，调用`await()`的线程将被阻塞。
3. **继续执行**：当所有线程都到达屏障点后，可以选择执行一个可选的`Runnable`命令，然后所有线程将继续执行。

**CyclicBarrier实例代码：**

```javaimport java.util.concurrent.CyclicBarrier;
import java.util.concurrent.TimeUnit;

public class CyclicBarrierExample {
 private static final int THREAD_COUNT =5;
 private static final CyclicBarrier barrier = new CyclicBarrier(THREAD_COUNT, () -> {
 System.out.println("All threads have reached the barrier.");
 });

public static void main(String[] args) {
 for (int i =0; i < THREAD_COUNT; i++) {
 new Thread(new Worker()).start();
 }
 }

static class Worker implements Runnable {
@Override public void run() {
 try {
 System.out.println(Thread.currentThread().getName() + " is running.");
Thread.sleep(1000); //模拟工作 barrier.await(); //等待所有线程到达屏障 System.out.println(Thread.currentThread().getName() + " continues after barrier.");
} catch (Exception e) {
e.printStackTrace();
 }
 }
 }
}
```在这两个例子中，`Semaphore`用于控制对资源的并发访问，而`CyclicBarrier`用于确保所有线程在继续执行之前都到达了某个点。这两种工具在多线程编程中非常有用，可以帮助开发者更好地管理线程的同步和执行顺序。