Java中的CyclicBarrier、CountDownLatch和Semaphore的具体使用
作者：逆流的小鱼168
1.CountDownLatch
1.1 介绍和用途
CountDownLatch 是一个同步助手类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。
1.2 工作原理
它通过一个计数器来实现，我们初始化 CountDownLatch 对象时指定计数器的值，每当一个指定的操作执行完成后，计数值就减一。当计数值达到零时，它表示所有需要等待的操作都完成了，此时阻塞在 CountDownLatch 上的线程就可以恢复执行任务。
1.3 使用场景和示例代码
CountDownLatch 经常用于确保某些操作在继续执行应用程序剩余部分之前完成，例如，服务器的服务依赖在接受请求前必须初始化完成。
import java.util.concurrent.CountDownLatch;
public class ServiceLoader {
// 初始计数器为3，表示需要等待3个服务加载
private static final CountDownLatch latch = new CountDownLatch(3);
public static void main(String[] args) throws InterruptedException {
// 启动服务加载线程
new Thread(new Service("Service 1", latch)).start();
new Thread(new Service("Service 2", latch)).start();
new Thread(new Service("Service 3", latch)).start();
// 主线程等待服务加载完成
latch.await();
System.out.println("所有服务已加载完成，服务可以开始接收请求...");
}
static class Service implements Runnable {
private final String name;
private final CountDownLatch latch;
public Service(String name, CountDownLatch latch) {
this.name = name;
this.latch = latch;
}
@Override
public void run() {
try {
// 模拟服务加载耗时操作
Thread.sleep((long) (Math.random() * 1000));
System.out.println(name + " 服务加载完成.");
// 服务加载完成后，计数器减一
latch.countDown();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}
}
1.4 注意事项和最佳实践
CountDownLatch 的计数器无法被重置，如果需要一个能够重置计数的版本，可以考虑使用 CyclicBarrier。在使用时还需注意异常处理，避免由于异常造成的线程永远等待的情况。
2.CyclicBarrier
2.1 介绍和用途
CyclicBarrier 是一个同步助手类，它允许一组线程互相等待，直到所有线程都到达一个公共的屏障点（Barrier Point）后才继续执行。
2.2 工作原理
CyclicBarrier 通过内部计数器来跟踪到达屏障点的线程数。当线程到达屏障点时，它调用 await() 方法，并阻塞直到指定数量的线程都到达了屏障点。此时，屏障打开，所有阻塞的线程将继续执行。不同于 CountDownLatch，CyclicBarrier 是可重用的。
2.3 使用场景和示例代码
CyclicBarrier 常用于多线程计算数据的场景，需要等到全部线程完成计算，才能进行下一步的处理。
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.BrokenBarrierException;
public class DataProcessor {
private static final int NUMBER_OF_THREADS = 3;
private static CyclicBarrier barrier = new CyclicBarrier(NUMBER_OF_THREADS,
new Runnable() {
@Override
public void run() {
// 当所有线程到达屏障点时执行
System.out.println("所有计算完成，进行数据合并...");
}
});
public static void main(String[] args) {
for(int i = 0; i < NUMBER_OF_THREADS; i++) {
new Thread(new Worker(i)).start();
}
}
static class Worker implements Runnable {
private int id;
public Worker(int id) {
this.id = id;
}
@Override
public void run() {
try {
// 模拟数据处理
System.out.println("线程 #" + id + " 正在处理数据...");
Thread.sleep((long) (Math.random() * 1000));
System.out.println("线程 #" + id + " 数据处理完成，等待其他线程...");
// 等待其他线程都执行到这个点
barrier.await();
System.out.println("线程 #" + id + " 继续后续操作...");
} catch (InterruptedException | BrokenBarrierException e) {
e.printStackTrace();
}
}
}
}
2.4 与CountDownLatch的比较
与 CountDownLatch 相比，CyclicBarrier 可以在所有等待线程都被释放后重置计数器，而 CountDownLatch 不能重置。
2.5 注意事项和最佳实践
使用 CyclicBarrier 时需要注意，如果任何线程在等待过程中因为中断或者超时而提前离开屏障点, 或者等待线程的数目永远不足以达到屏障点，这将导致所有在屏障点等待的线程抛出 BrokenBarrierException。因此，在使用时需要妥善处理这些可能的异常场景。
为了避免这种情形，可以在 await 方法中设置一个超时时间，并适当处理 TimeoutException。同时，可以通过 isBroken 方法检查屏障点的状态，以便在必要时对线程进行重新安排或者重置屏障点。
除此之外，设计上建议只在所有参与线程要完成的任务确实需要互相等待时才使用 CyclicBarrier，在任务独立的情况下使用 CountDownLatch 会更为合适。
3.Semaphore
3.1 介绍和用途
Semaphore（信号量）是一种基于计数的同步机制，它可以用来控制同时访问特定资源的线程数量，是实现资源池或者限制容量的一个有力工具。
3.2 工作原理
Semaphore 管理一组许可证（permits），线程可以通过 acquire() 方法获取许可证，如果 Semaphore 内部计数为零，表示没有许可证可用，线程将会阻塞直到有许可证被释放。相反，线程完成任务后，可以通过 release() 方法释放许可证，并将其返回给信号量。
3.3 使用场景和示例代码
Semaphore 通常用于对资源池进行控制，比如数据库连接池，限制同时访问的连接数，或者在限流控制中限制同时执行的线程数量。
import java.util.concurrent.Semaphore;
public class ResourcePool {
private static final int MAX_AVAILABLE = 5;
private final Semaphore available = new Semaphore(MAX_AVAILABLE, true);
public Object getItem() throws InterruptedException {
available.acquire();
try {
// 模拟获取资源的操作
return getNextAvailableItem();
} finally {
// 保证在资源使用后一定会释放许可证
available.release();
}
}
// 此处省略了资源管理的其他逻辑...
public static void main(String[] args) {
final ResourcePool pool = new ResourcePool();
for (int i = 0; i < 10; i++) {
new Thread(() -> {
try {
Object item = pool.getItem();
// 模拟使用资源
System.out.println(Thread.currentThread().getName() + " 获取了资源");
Thread.sleep((long) (Math.random() * 1000));
// 假设这里是使用资源完成后的操作
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}).start();
}
}
// 此处省略了getNextAvailableItem方法的实现，它应该负责分配资源
}
在以上代码示例中，我们设置了最大并发数，并通过 Semaphore 来限制访问资源的线程数。当所有许可证都被占用时，后来的线程将会等待直到有线程释放许可证。
3.4 和其他同步工具的比较
相比其他同步工具，Semaphore 提供了对资源的并发访问控制，而 CountDownLatch 和 CyclicBarrier 更侧重于线程的协调和等待。
3.5 注意事项和最佳实践
使用 Semaphore 时，要确保在资源使用后，准确无误地释放许可证，否则可能会导致其他线程永久等待。在实际应用中，尤其在复杂的业务逻辑里，通常建议使用 try-finally` 语句确保许可证的正确释放。
同时，合理配置许可证的数量对于系统的稳定性和性能至关重要。对于资源竞争激烈的场景，设置过少的许可证可能会导致系统响应时间增长；反之，设置过多的许可证则可能会超出系统资源的实际承载能力，造成资源的浪费或系统崩溃。
总结
到此这篇关于Java中的CyclicBarrier、CountDownLatch和Semaphore的具体使用的文章就介绍到这了,更多相关Java CyclicBarrier CountDownLatch Semaphore内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！