CountDownLatch(闭锁)使用详解_countdownlatch 中文翻译-CSDN博客

CountDownLatch是一个同步辅助类，用于多线程并发控制，确保所有线程完成特定操作后再继续执行。它拥有一个正计数器，通过countDown()方法递减，await()方法则会阻塞直到计数器为0。两种典型用法包括：1) 主线程等待多个子线程执行完毕；2) 实现多线程最大并行性启动。CountDownLatch基于AQS实现，一次性使用，初始化后的计数值无法改变。

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

在开发中遇到了多线程并发等问题，发现对于多线程并发来说CountDownLatch使用起来还是比较好用的，接下来对它做一次总结。

1. CountDownLatch是什么

CountDownLatch，英文翻译为倒计时锁存器，是一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。

闭锁可以延迟线程的进度直到其到达终止状态，闭锁可以用来确保某些活动直到其他活动都完成才继续执行：

确保某个计算在其需要的所有资源都被初始化之后才继续执行;
确保某个服务在其依赖的所有其他服务都已经启动之后才启动;
等待直到某个操作所有参与者都准备就绪再继续执行。

CountDownLatch有一个正数计数器，countDown()方法对计数器做减操作，await()方法等待计数器达到0。所有await的线程都会阻塞直到计数器为0或者等待线程中断或者超时。

闭锁(倒计时锁)主要用来保证完成某个任务的先决条件满足。是一个同步工具类，用来协调多个线程之间的同步。这个工具通常用来控制线程等待，它可以让某一个线程等待直到倒计时结束，再开始执行。

CountDownLatch同样依赖队列同步器AbstractQueuedSynchronizer，其类方法如下：
在这里插入图片描述
其内部类Sync同样继承了AQS并重写了tryAcquireShared和tryReleaseShared方法。同时也可以表明CountDownLatch是基于共享锁模式的。

2. CountDownLatch 的两种典型用法

某一线程在开始运行前等待n个线程执行完毕。

将 CountDownLatch 的计数器初始化为n ：new CountDownLatch(n)，每当一个任务线程执行完毕，就将计数器减1，countdownlatch.countDown()，当计数器的值变为0时，在CountDownLatch上 await()的线程就会被唤醒。一个典型应用场景就是启动一个服务时，主线程需要等待多个组件加载完毕，之后再继续执行。

实现多个线程开始执行任务的最大并行性。

注意是并行性，不是并发，强调的是多个线程在某一时刻同时开始执行。类似于赛跑，将多个线程放到起点，等待发令枪响，然后同时开跑。做法是初始化一个共享的 CountDownLatch 对象，将其计数器初始化为 1 ：new CountDownLatch(1)，多个线程在开始执行任务前首先coundownlatch.await()，当主线程调用 countDown() 时，计数器变为0，多个线程同时被唤醒。

如下示例，在多线程运行情况下，计算多线程耗费时间：

public class TestCountDownLatch {

    public static void main(String[] args){

        LatchDemo latchDemo = new LatchDemo();

        long begin = System.currentTimeMillis();
		//多线程
        for (int i = 0; i <5 ; i++) {
            new Thread(latchDemo).start();
        }
        //主线程
        long end = System.currentTimeMillis();
        
        System.out.println("耗费时间："+(end-begin));

    }
}

class LatchDemo implements  Runnable{

    @Override
    public void run() {

        for (int i = 0; i < 50000; i++) {
            if (i%2==0){
                System.out.println(i);
            }
        }

    }
}

3. CountDownLatch源码分析与使用

修改上述中代码如下：

public class TestCountDownLatch {

    public static void main(String[] args){
		//CountDownLatch 为唯一的、共享的资源
        final CountDownLatch latch = new CountDownLatch(5);
		
        LatchDemo latchDemo = new LatchDemo(latch);

        long begin = System.currentTimeMillis();

        for (int i = 0; i <5 ; i++) {
            new Thread(latchDemo).start();
        }
        try {
            //多线程运行结束前一直等待
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long end = System.currentTimeMillis();
        
        System.out.println("耗费时间："+(end-begin));

    }
}

class LatchDemo implements  Runnable{

    private CountDownLatch latch;

    public LatchDemo(CountDownLatch latch){
        this.latch=latch;
    }
    public LatchDemo(){
        super();
    }

    @Override
    public void run() {
        //当前对象唯一，使用当前对象加锁，避免多线程问题
        synchronized (this){
            try {
                for (int i = 0; i < 50000; i++) {
                    if (i%2==0){
                        System.out.println(i);
                    }
                }
            }finally {
                //保证肯定执行
                latch.countDown();
            }
        }
    }
}

CountDownLatch源码如下：

package java.util.concurrent;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;

public class CountDownLatch {
    /**
     * CountDownLatch的同步控制，同样依赖使用AQS，使用AQS state表示count计数
     */
    private static final class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 4982264981922014374L;

        Sync(int count) {
        	//设置初始计数
            setState(count);
        }

        int getCount() {
        	//获取当前计数
            return getState();
        }

//这里重写了AQS的tryAcquireShared方法，小于0表示count>0，可以获取。
        protected int tryAcquireShared(int acquires) {
            return (getState() == 0) ? 1 : -1;
        }

        protected boolean tryReleaseShared(int releases) {
        //count-1，如果count变为0，则唤醒所有
            for (;;) {
            	//获取当前状态，为0表示未锁，不用释放
                int c = getState();
                if (c == 0)
                    return false;
                int nextc = c-1;
                //使用CAS算法，c为期望值，nextc为更新值
                if (compareAndSetState(c, nextc))
                    return nextc == 0;
            }
        }
    }
    private final Sync sync;
    /**
使用给定的count构造CountDownLatch，count表示线程通过await前必须要执行的次数，count不能小于0
     */
    public CountDownLatch(int count) {
        if (count < 0) throw new IllegalArgumentException("count < 0");
        this.sync = new Sync(count);
    }

    /**
     让当前线程等待直到count减数为0，除非线程被中断。如果count为0，线程将立即返回--不再阻塞等待。
     如果当前计数大于零，则出于线程调度目的，当前线程将禁用，并处于休眠状态，直到发生以下两种情况之一：
	     1.countDown方法调用导致count减数为0；
	     2.别的线程中断了当前线程
     * 线程等待时，如果被中断将会抛出InterruptedException异常
     */
    public void await() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }

  /**
	使当前线程处理等待状态直到count减为0或者指定等待时间过去。
	如果当前count是0，则线程立即返回true。
	如果当前计数大于零，则出于线程调度目的，当前线程将禁用，并处于休眠状态，直到发生以下		三种情况之一：
     	1.countDown方法调用导致count减数为0；
     	2.别的线程中断了当前线程
     	3.指定等待时间过去   
	如果等待时间过去但是count>0，则返回false。如果等待时间时间小于或等于零，方法将不会等待。
*/
    public boolean await(long timeout, TimeUnit unit)
        throws InterruptedException {
        return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
    }

    /**
     * 将count-1 ，如果count减一后为0 ，则释放所有等待的线程
     */
    public void countDown() {
        sync.releaseShared(1);
    }

    /**
     返回当前的count，该方法通常用在debug或者测试中
     */
    public long getCount() {
        return sync.getCount();
    }

    public String toString() {
        return super.toString() + "[Count = " + sync.getCount() + "]";
    }
}

简单总结如下：

内部类Sync同样继承AQS；
AQS的state代表count；
初始化使用计数器count；
count代表多个线程执行或者某个操作执行次数；
countDown()方法将会将count-1；
count为0将会释放所有等待线程；
await方法将会阻塞直到count为0；
CountDownLatch是一次性的，计数器的值只能在构造方法中初始化一次，之后没有任何机制再次对其设置值，当CountDownLatch使用完毕后，它不能再次被使用。
count不为0，但是等待时间过去将会返回false。
开关锁应用；
问题分解应用–并行性；