Java并发编程：CountDownLatch、CyclicBarrier和Semaphore的个人理解

最新推荐文章于 2022-07-10 11:56:10 发布

Soul_clannad

最新推荐文章于 2022-07-10 11:56:10 发布

阅读量251

点赞数

CC 4.0 BY-SA版权

分类专栏：个人随笔

本文链接：https://blog.youkuaiyun.com/Soul_clannad/article/details/85626605

个人随笔专栏收录该内容

2 篇文章

订阅专栏

本文深入解析CountDownLatch、CyclicBarrier和Semaphore三种并发控制工具的使用方法、工作原理及应用场景，帮助理解多线程环境中如何合理分配资源，实现线程间的同步与等待。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.CountDownLatch是一个同步工具类，它允许一个或多个线程一直等待，直到其他线程的操作执行完后再执行。（一个主线程启动，多个线程启动，然后等待所有线程全部运行结束，然后返回主线程，主线程结束）

2.上述图片中可设定countdownlatch等待线程的数量；假设等待数量为10，则表示你需要等待10个线程完全执行完毕才会结束；假设启动5个线程，则表示他将一直等待中（没有足够的线程）（图1）；当启动线程的数量大于等待的数量时，等待设定数量后的线程后，他将主动结束主线程，而其他线程则未等待且其他线程执行中（图2）；

(图1）

（图2）

3.CountDownLatch.java类中定义的构造函数：

构造器中的计数值（count）实际上就是闭锁需要等待的线程数量。这个值只能被设置一次，而且CountDownLatch没有提供任何机制去重新设置这个计数值。与CountDownLatch的第一次交互是主线程等待其他线程。主线程必须在启动其他线程后立即调用CountDownLatch.await()方法。这样主线程的操作就会在这个方法上阻塞，直到其他线程完成各自的任务。其他N 个线程必须引用闭锁对象，因为他们需要通知CountDownLatch对象，他们已经完成了各自的任务。这种通知机制是通过 CountDownLatch.countDown()方法来完成的；每调用一次这个方法，在构造函数中初始化的count值就减1。所以当N个线程都调用了这个方法，count的值等于0，然后主线程就能通过await()方法，恢复执行自己的任务。

4.使用场景.

死锁检测：一个非常方便的使用场景是，你可以使用n个线程访问共享资源，在每次测试阶段的线程数目是不同的，并尝试产生死锁。

5.简单的使用情况（简单介绍CountDownLatch用法）

2.CyclicBarrier的用法示例（初始化设定数目，当调用了进入等待的线程时，且当线程数量等于初始化设定的数目时，所有等待的线程被唤醒继续执行；如设定初始化数量大于启动数量但并未达到启动数量，则进入等待状态；例如初始化设定4个，启动7个线程，则其中四个线程会进入运行状态并执行，其他三个线程则会进入等待状态；如果启动线程数量是初始化设定的倍数，则都会执行;这就是环状，执行完任务后可以继续使用；）

3.Semaphore的工作原理及实例

Semaphore是一种在多线程环境下使用的设施，该设施负责协调各个线程，以保证它们能够正确、合理的使用公共资源的设施，也是操作系统中用于控制进程同步互斥的量。Semaphore是一种计数信号量，用于管理一组资源，内部是基于AQS的共享模式。它相当于给线程规定一个量从而控制允许活动的线程数

以一个停车场是运作为例。为了简单起见，假设停车场只有三个车位，一开始三个车位都是空的。这时如果同时来了五辆车，看门人允许其中三辆不受阻碍的进入，然后放下车拦，剩下的车则必须在入口等待，此后来的车也都不得不在入口处等待。这时，有一辆车离开停车场，看门人得知后，打开车拦，放入一辆，如果又离开两辆，则又可以放入两辆，如此往复。这个停车系统中，每辆车就好比一个线程，看门人就好比一个信号量，看门人限制了可以活动的线程。假如里面依然是三个车位，但是看门人改变了规则，要求每次只能停两辆车，那么一开始进入两辆车，后面得等到有车离开才能有车进入，但是得保证最多停两辆车。对于Semaphore类而言，就如同一个看门人，限制了可活动的线程数。

Semaphore主要方法：

Semaphore(int permits):构造方法，创建具有给定许可数的计数信号量并设置为非公平信号量。

Semaphore(int permits,boolean fair):构造方法，当fair等于true时，创建具有给定许可数的计数信号量并设置为公平信号量。

void acquire():从此信号量获取一个许可前线程将一直阻塞。相当于一辆车占了一个车位。

void acquire(int n):从此信号量获取给定数目许可，在提供这些许可前一直将线程阻塞。比如n=2，就相当于一辆车占了两个车位。

void release():释放一个许可，将其返回给信号量。就如同车开走返回一个车位。

void release(int n):释放n个许可。

int availablePermits()：当前可用的许可数。

package semaphore;

import java.util.concurrent.Semaphore;

import java.util.concurrent.ThreadPoolExecutor;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.LinkedBlockingQueue;

public class SemaphoreDemo {

private static final Semaphore semaphore = new Semaphore(3);

private static final ThreadPoolExecutor threadPool = new ThreadPoolExecutor(5, 10, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());

private static class InformationThread extends Thread {

private final String name;

private final int age;

public InformationThread(String name, int age) {

this.name = name;

this.age = age;

}

public void run() {

try {

semaphore.acquire();

System.out.println(Thread.currentThread().getName() + ":大家好，我是" + name + "我今年" + age + "岁当前时间为：" + System.currentTimeMillis());

Thread.sleep(1000);

System.out.println(name + "要准备释放许可证了，当前时间为：" + System.currentTimeMillis());

semaphore.release();

System.out.println("当前可使用的许可数为：" + semaphore.availablePermits());

} catch (InterruptedException e) {

e.printStackTrace();

}

public static void main(String[] args) {

String[] name = {"李明", "王五", "张杰", "王强", "赵二", "李四", "张三"};

int[] age = {26, 27, 33, 45, 19, 23, 41};

for (int i = 0; i < 7; i++) {

Thread t1 = new InformationThread(name[i], age[i]);

threadPool.execute(t1);

}

Semaphore主要用于控制当前活动线程数目，就如同停车场系统一般，而Semaphore则相当于看守的人，用于控制总共允许停车的停车位的个数，而对于每辆车来说就如同一个线程，线程需要通过acquire()方法获取许可，而release()释放许可。如果许可数达到最大活动数，那么调用acquire()之后，便进入等待队列，等待已获得许可的线程释放许可，从而使得多线程能够合理的运行。

总结
代码示例
工作原理
简介
System.out.println("Inside Barrier");
}
});
for (int i = 0; i < 8; i++) {
new Thread(new WorkerThread(cb)).start();
}
}
}
public void run() {
@Override
CyclicBarrier cb = new CyclicBarrier(THREAD_NUM, new Runnable() {
//当所有线程到达barrier时执行
* @param args
*/
public static void main(String[] args) {
System.out.println("ID:" + Thread.currentThread().getId() + " Working");
} catch (Exception e) {
e.printStackTrace();
}finally {
System.out.println(Thread.currentThread().getId() + "工作！");
}
}
}
/**
barrier.await();
try {
System.out.println(Thread.currentThread().getId() + " waiting");
//线程在这里等待，直到所有线程都到达barrier。
public void run() {
private static final int THREAD_NUM = 4;
public static class WorkerThread implements Runnable {
CyclicBarrier barrier;
public WorkerThread(CyclicBarrier b) {
this.barrier = b;
}
@Override
public class TestCyclicBarrier {
CyclicBarrier初始化时规定一个数目，然后计算调用了CyclicBarrier.await()进入等待的线程数。当线程数达到了这个数目时，所有进入等待状态的线程被唤醒并继续。
CyclicBarrier就象它名字的意思一样，可看成是个障碍，所有的线程必须到齐后才能一起通过这个障碍。
CyclicBarrier初始时还可带一个Runnable的参数，此Runnable任务在CyclicBarrier的数目达到后，所有其它线程被唤醒前被执行。
public static void main(String[] args) {
final CountDownLatch latch = new CountDownLatch(2);
new Thread(){
public void run() {
try {
System.out.println("子线程"+Thread.currentThread().getName()+"正在执行");
Thread.sleep(5000);
System.out.println("子线程"+Thread.currentThread().getName()+"执行完毕");
latch.countDown();
} catch (InterruptedException e) {
e.printStackTrace();
}
};
}.start();
new Thread(){
public void run() {
try {
System.out.println("子线程"+Thread.currentThread().getName()+"正在执行");
Thread.sleep(6000);
System.out.println("子线程"+Thread.currentThread().getName()+"执行完毕");
latch.countDown();
} catch (InterruptedException e) {
e.printStackTrace();
}
};
}.start();
try {
latch.await();
System.out.println("等待2个子线程执行完毕...");
System.out.println("2个子线程已经执行完毕");
System.out.println("继续执行主线程");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public class Test1 {
实现最大的并行性：有时我们想同时启动多个线程，实现最大程度的并行性。例如，我们想测试一个单例类。如果我们创建一个初始计数为1的CountDownLatch，并让所有线程都在这个锁上等待，那么我们可以很轻松地完成测试。我们只需调用一次countDown()方法就可以让所有的等待线程同时恢复执行。
开始执行前等待n个线程完成各自任务：例如应用程序启动类要确保在处理用户请求前，所有N个外部系统已经启动和运行了。