CountDownLatch学习

原创已于 2023-02-19 17:37:45 修改

· 341 阅读

0 ·

版权

文章标签：

#java #开发语言

于 2022-06-10 19:43:39 首次发布

并发编程专栏收录该内容

6 篇文章

订阅专栏

本文详细介绍了Java并发工具类CountDownLatch的原理与使用，包括其在多线程同步、等待所有线程执行完成等场景的应用，并给出了跑步比赛的示例代码，同时深入解析了CountDownLatch的源码，展示了await()方法的内部机制。此外，还列举了CountDownLatch在实际开发中的常见使用场景。

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

CountDownLatch

允许一个或多个线程去等待其他线程完成操作之后这个线程才能完成后续的任务
举例：在数据海量的情况下去导入(导出)数据，先会开启多个工作线程去完成导入/导出任务，任务完成之后才会把将最终导入后的时间存入操作日志数据库表，并且会将导入前时间与完成导入的时间做运算，最后得到花费的时间，这种场景，就可以使用CountDownLatch

定义固定导入线程数量
CountDownLatch c = new CountDownLatch(导入线程数量)，记录导入开始时间
主线程调用await方法阻塞主线程，此时每完成一批导入任务，就执行countDown方法
完成所有导入任务之后主线程不再阻塞，记录下完成时间，最后运算存入数据库-日志表中
此时主线程再搞其他事情

1、简介、

作用：等待其他的线程都执行完任务，必要时可以对各个任务的执行结果进行汇总，然后主线程才继续往下执行。
不一定是多线程，在单线程中可以用这个int型参数表示多个操作步骤。
构造器需要传入一个整数n，在这个整数“倒数”到0之前，主线程处于阻塞需要等待，而这个“倒数”过程则是由各个工作程驱动的，每个线程执行完一个任务“倒数”一次。

2、类构造器、常用方法、成员变量、成员类：

package java.util.concurrent;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
 /*
 * @since 1.5
 * @author Doug Lea
 */
public class CountDownLatch {}

构造器：

    public CountDownLatch(int count) {
        if (count < 0) throw new IllegalArgumentException("count < 0");//如果个数小于0，直接抛参数异常
        this.sync = new Sync(count);
    }

常用方法:

	//使当前线程进入阻塞状态，即同步队列等待
	//两种情况下唤醒：count降为0，当前线程中断
    public void await() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }
    //带超时间，满足超时时间自动唤醒
    public boolean await(long timeout, TimeUnit unit) throws InterruptedException {
        return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
    }
    //count 降1，也意味着有一个工作线程完成了任务，当它降为0时就会唤醒所有等待这个count的线程
     public void countDown() {
        sync.releaseShared(1);
    }
    //获取count的数值
     public long getCount() {
        return sync.getCount();
    }
    public String toString() {
        return super.toString() + "[Count = " + sync.getCount() + "]";
    }

成员变量：

private final Sync sync;//关键
private static final long serialVersionUID = 4982264981922014374L;//序列化版本号

内部类：Sync

private static final class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 4982264981922014374L;//序列化版本号
        Sync(int count) {//构造器- 设置同步状态的值
            setState(count);//设置同步状态的值
        }
        int getCount() {//获得个数
            return getState();//获取同步状态的值
        }
        //尝试获取同步状态，只有状态值为0的时候才会成功
        protected int tryAcquireShared(int acquires) {
            return (getState() == 0) ? 1 : -1;
        }
        //尝试释放同步状态，每次释放通过CAS将同步状态的值减1
        protected boolean tryReleaseShared(int releases) {
            for (;;) {
                int c = getState();//获取同步状态的值
                if (c == 0)//同步状态等于0时，获取同步状态失败，返回false，跳出循环
                    return false;
                int nextc = c-1;//否则为同步状态值减一
                if (compareAndSetState(c, nextc))//CAS(比较并设置值)，比较c和最新同步状态设置成功，
                    return nextc == 0;//判断nextc，等于0返回true，否则返回false
                   //CAS失败再次循环
            }
        }
    }

静态私有不变内部类
继承与 AbstractQueuedSynchronizer(AQS)抽象队列同步器

三、测试demo

3.1、跑步比赛

public class CountdownLatchTest2 {
    public static void main(String[] args) {
        ExecutorService service = Executors.newCachedThreadPool();
        final CountDownLatch cdOrder = new CountDownLatch(1);
        final CountDownLatch cdAnswer = new CountDownLatch(4);
        for (int i = 0; i < 4; i++) {
            service.execute(()->{
                try {
                    System.out.println("选手" + Thread.currentThread().getName() + "正在等待裁判发布口令");
                    cdOrder.await();
                    System.out.println("选手" + Thread.currentThread().getName() + "已接受裁判口令");
                    Thread.sleep((long) (Math.random() * 10000));
                    System.out.println("选手" + Thread.currentThread().getName() + "到达终点");
                    cdAnswer.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
        try {
            Thread.sleep((long) (Math.random() * 10000));
            System.out.println("裁判"+Thread.currentThread().getName()+"即将发布口令");
            cdOrder.countDown();
            System.out.println("裁判"+Thread.currentThread().getName()+"已发送口令，正在等待所有选手到达终点");
            cdAnswer.await();
            System.out.println("所有选手都到达终点");
            System.out.println("裁判"+Thread.currentThread().getName()+"汇总成绩排名");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        service.shutdown();
    }
}

四、源码分析：

4.1、await()

public void await() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }

调用AQS的acquireSharedInterruptibly方法

public final void acquireSharedInterruptibly(int arg) throws InterruptedException {
        if (Thread.interrupted()) throw new InterruptedException();//线程中断，抛出异常
        //尝试获取同步状态《0
        if (tryAcquireShared(arg) < 0) doAcquireSharedInterruptibly(arg);//自旋
    }

通过tryAcquireShared(arg)尝试获取同步状态,具体的方法被sync重写了

   //尝试获取同步状态，只有状态值为0的时候才会成功
   //尝试获取latch的线程只有当latch的值减到0的时候，才能获取成功。
    protected int tryAcquireShared(int acquires) {
        return (getState() == 0) ? 1 : -1;
    }

获取失败，则会调用AQS的doAcquireSharedInterruptibly(int arg)函数自旋，尝试挂起当前线程：

private void doAcquireSharedInterruptibly(int arg)
    throws InterruptedException {
    // 将当前线程加入同步队列的尾部
    final Node node = addWaiter(Node.SHARED);
    try {
        // 自旋
        for (;;) {
            // 获取当前节点的前驱节点
            final Node p = node.predecessor();
            // 如果前驱节点是头结点，则尝试获取同步状态
            if (p == head) {
                // 当前节点尝试获取同步状态
                int r = tryAcquireShared(arg);
                if (r >= 0) {
                    // 如果获取成功，则设置当前节点为头结点
                    setHeadAndPropagate(node, r);
                    p.next = null; // help GC
                    return;
                }
            }
            // 如果当前节点的前驱不是头结点，尝试挂起当前线程
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                throw new InterruptedException();
        }
    } catch (Throwable t) {
        cancelAcquire(node);
        throw t;
    }
}
//shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt() 挂起当前线程

五、使用场景：

5.1：等待n个线程执行。

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