CountDownLatch在多线程并发编程中充当一个计时器的功能,并且维护一个count的变量,并且其操作都是原子操作。
如下图,内部有下static final的Sync类继承自AQS.
该类主要通过countDown()和await()两个方法实现功能的,首先通过建立CountDownLatch对象,并且传入参数即为count初始值。
如果一个线程调用了await()方法,那么这个线程便进入阻塞状态,并进入阻塞队列。
如果一个线程调用了countDown()方法,则会使count-1;当count的值为0时,这时候阻塞队列中调用await()方法的线程便会逐个被唤醒,从而进入后续的操作。
补充:Java并发包中CountDownLatch的工作原理、使用示例
1. CountDownLatch的介绍
CountDownLatch是一个同步工具,它主要用线程执行之间的协作。CountDownLatch 的作用和 Thread.join() 方法类似,让一些线程阻塞直到另一些线程完成一系列操作后才被唤醒。在直接创建线程的年代(Java 5.0 之前),我们可以使用 Thread.join()。在线程池出现后,因为线程池中的线程不能直接被引用,所以就必须使用 CountDownLatch 了。
CountDownLatch主要有两个方法,当一个或多个线程调用await方法时,这些线程会阻塞。其它线程调用countDown方法会将计数器减1(调用countDown方法的线程不会阻塞),当计数器的值变为0时,因await方法阻塞的线程会被唤醒,继续执行。
实现原理:计数器的值由构造函数传入,并用它初始化AQS的state值。当线程调用await方法时会检查state的值是否为0,如果是就直接返回(即不会阻塞);如果不是,将表示该节点的线程入列,然后将自身阻塞。当其它线程调用countDown方法会将计数器减1,然后判断计数器的值是否为0,当它为0时,会唤醒队列中的第一个节点,由于CountDownLatch使用了AQS的共享模式,所以第一个节点被唤醒后又会唤醒第二个节点,以此类推,使得所有因await方法阻塞的线程都能被唤醒而继续执行。
从源代码和实现原理中可以看出一个CountDownLatch对象,只能使用一次,不能重复使用。
await方法源码
- public void await() throws InterruptedException {
- sync.acquireSharedInterruptibly(1);
- }
- public final void acquireSharedInterruptibly(int arg)
- throws InterruptedException {
- if (Thread.interrupted())
- throw new InterruptedException();
- if (tryAcquireShared(arg) < 0)
- doAcquireSharedInterruptibly(arg);
- }
- protected int tryAcquireShared(int acquires) {
- return (getState() == 0) ? 1 : -1;
- }
doAcquireSharedInterruptibly 主要实现线程的入列与阻塞。
countDown方法
- public void countDown() {
- sync.releaseShared(1);
- }
- public final boolean releaseShared(int arg) {
- if (tryReleaseShared(arg)) {
- doReleaseShared();
- return true;
- }
- return false;
- }
- protected boolean tryReleaseShared(int releases) {
- // Decrement count; signal when transition to zero
- for (;;) {
- int c = getState();
- if (c == 0)
- return false;
- int nextc = c-1;
- if (compareAndSetState(c, nextc))
- return nextc == 0;
- }
- }
doReleaseShared主要实现唤醒第一个节点,第一个节点有会唤醒第二个节点,……。
2. 使用示例
- package demo;
- import java.util.Random;
- import java.util.concurrent.CountDownLatch;
- import java.util.concurrent.ExecutorService;
- import java.util.concurrent.Executors;
- public class CountDownLatchDemo {
- private CountDownLatch cdl = new CountDownLatch(2);
- private Random rnd = new Random();
- class FirstTask implements Runnable{
- private String id;
- public FirstTask(String id){
- this.id = id;
- }
- @Override
- public void run(){
- System.out.println("Thread "+ id + " is start");
- try {
- Thread.sleep(rnd.nextInt(1000));
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- System.out.println("Thread "+ id + " is over");
- cdl.countDown();
- }
- }
- class SecondTask implements Runnable{
- private String id;
- public SecondTask(String id){
- this.id = id;
- }
- @Override
- public void run(){
- try {
- cdl.await();
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- System.out.println("----------Thread "+ id + " is start");
- try {
- Thread.sleep(rnd.nextInt(1000));
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- System.out.println("----------Thread "+ id + " is over");
- }
- }
- public static void main(String[] args){
- ExecutorService es = Executors.newCachedThreadPool();
- CountDownLatchDemo cdld = new CountDownLatchDemo();
- es.submit(cdld.new SecondTask("c"));
- es.submit(cdld.new SecondTask("d"));
- es.submit(cdld.new FirstTask("a"));
- es.submit(cdld.new FirstTask("b"));
- es.shutdown();
- }
- }
在这个示例中,我们创建了四个线程a、b、c、d,这四个线程几乎同时提交给了线程池。c线程和d线程会在a线程和b线程结束后开始执行。
运行结果
- Thread a is start
- Thread b is start
- Thread b is over
- Thread a is over
- ----------Thread c is start
- ----------Thread d is start
- ----------Thread d is over
- ----------Thread c is over
以上为个人经验,希望能给大家一个参考,也希望大家多多支持服务器之家。如有错误或未考虑完全的地方,望不吝赐教。
原文链接:https://blog.csdn.net/kangbin825/article/details/105397247