深入理解Java中并发工具类：如Semaphore、CyclicBarrier等示例

原创骑猪看日落 2024-12-06 15:45 129阅读 0赞

在Java中，并发工具类是用于管理线程和资源的。其中最常用的两个类是Semaphore（信号量）和CyclicBarrier（循环屏障）。

1. Semaphore（信号量）

Semaphore是一种线程同步机制，它允许有限数量的并发实体访问特定资源。

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

public class SemaphoreExample {
    private Semaphore semaphore = new Semaphore(3); // 允许3个并发线程

public void countDown() throws InterruptedException {
        semaphore.acquire(); // 获取信号量，当数量为0时阻塞
        System.out.println("Thread " + Thread.currentThread().getId() + " is counting down...");

try {
            semaphore.release(); // 释放信号量，当数量不为0时唤醒阻塞的线程
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

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

Thread thread1 = new Thread(() -> {
            try {
                example.countDown();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }));

Thread thread2 = new Thread(() -> {
            try {
                example.countDown();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }));

thread1.start();
        thread2.start();
    }
}
```
在这个示例中，Semaphore允许最多3个线程同时访问资源。每个线程在调用countDown()时会尝试获取信号量，如果数量为0（表示已满），线程会被阻塞。当释放信号量（数变大）时，阻塞的线程会被唤醒并继续执行。

2. CyclicBarrier（循环屏障）

CyclicBarrier是一个线程同步工具，用于一组等待某个事件完成的线程。

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

public class CyclicBarrierExample {
    private CyclicBarrier barrier = new CyclicBarrier(2); // 允许2个并发线程

public void printMessage() throws InterruptedException {
        barrier.await(); // 等待屏障到达下一个阶段

System.out.println("Thread " + Thread.currentThread().getId() + " is printing message...");

try {
            barrier.signalAll(); // 将信号发送到所有等待的线程
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

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

Thread thread1 = new Thread(() -> {
            try {
                example.printMessage();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }));

Thread thread2 = new Thread(() -> {
            try {
                example.printMessage();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }));

thread1.start();
        thread2.start();
    }
}
```
在这个示例中，CyclicBarrier允许最多2个并发线程。每个线程在调用printMessage()时会等待屏障到达下一个阶段。当信号发送到所有等待的线程（barrier.signalAll()）时，线程将被唤醒并继续执行。