007-多线程-锁-JUC锁-CountDownLatch-闭锁【允许一个或多个线程，等待其他一组线程完成操作，再继续执行】...

最新推荐文章于 2024-11-11 21:19:25 发布
最新推荐文章于 2024-11-11 21:19:25 发布
阅读量136 收藏
点赞数
文章标签： java
原文链接：http://www.cnblogs.com/bjlhx/p/10365871.html
版权

一、概述　　

　　CountDownLatch是JAVA提供在java.util.concurrent包下的一个辅助类，指定的一个或多个线程等待其他线程执行完成后执行。

　　能够使一个线程等待其他线程完成各自的工作后再执行。例如，应用程序的主线程希望在负责启动框架服务的线程已经启动所有的框架服务之后再执行。

　　闭锁是一种同步工具类，可以延迟线程的进度，直到其到达终止状态。闭锁的作用相当于一扇门：在闭锁到达结束状态之前，这扇门一直是关闭的，并且没有任何线程能够通过，当达到结束状态时，这扇门会打开并允许所有的线程通过。当闭锁到达结束状态后，将不会再改变状态，因此这扇门将永远保持打开状态。闭锁可以确保某些活动直到其他活动都完成之后才继续执行。

　　CountDownLatch是一种灵活的闭锁实现，它允许一个或多个线程等待一组事件的产生。闭锁状态包括一个计数器，该计数器初始化为一个正数，表示需要等待的事件数量。countDown方法递减计数器，表示有一个事件已经发生了，而await方法会一直阻塞直到计数器为0，或者等待中的线程中断，或者等待超时。

1.1、主要方法

// 构造器，必须指定一个大于零的计数
public CountDownLatch(int count) {
    if (count < 0) throw new IllegalArgumentException("count < 0");
    this.sync = new Sync(count);
}

// 线程阻塞，直到计数为0的时候唤醒；可以响应线程中断退出阻塞
public void await() throws InterruptedException {
    sync.acquireSharedInterruptibly(1);
}

// 线程阻塞一段时间，如果计数依然不是0，则返回false；否则返回true
public boolean await(long timeout, TimeUnit unit)
    throws InterruptedException {
    return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
}

// 计数-1
public void countDown() {
    sync.releaseShared(1);
}

// 获取计数
public long getCount() {
    return sync.getCount();
}

　　　　它的内部有一个辅助的内部类：sync

　　countDownLath无法被重置，循环栅栏可以。

　　循环栅栏是要执行的线程增加，countDownLatch是执行完成的线程增加。

1.2、实现原理

　　同ReentrantLock一样，依然是借助AQS的双端队列，来实现原子的计数-1，线程阻塞和唤醒

　　参看：013-AbstractQueuedSynchronizer-用于构建锁和同步容器的框架

1. 计数器的初始化

　　CountDownLatch内部实现了AQS，并覆盖了tryAcquireShared()和tryReleaseShared()两个方法，下面说明干嘛用的

　　通过前面的使用，清楚了计数器的构造必须指定计数值,这个直接初始化了 AQS内部的state变量

Sync(int count) {
    setState(count);
}

　　后续的计数-1/判断是否可用都是基于state进行的

2. countDown() 计数-1的实现

// 计数-1
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) //如果计数已经为0，则返回失败
            return false;
        int nextc = c-1;
        // 原子操作实现计数-1
        if (compareAndSetState(c, nextc)) 
            return nextc == 0;
    }
}

// 唤醒被阻塞的线程
private void doReleaseShared() {
    for (;;) {
        Node h = head;
        if (h != null && h != tail) { // 队列非空，表示有线程被阻塞
            int ws = h.waitStatus;
            if (ws == Node.SIGNAL) { 
            // 头结点如果为SIGNAL,则唤醒头结点下个节点上关联的线程，并出队
                if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                    continue;            // loop to recheck cases
                unparkSuccessor(h);
            }
            else if (ws == 0 &&
                     !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                continue;                // loop on failed CAS
        }
        if (h == head) // 没有线程被阻塞，直接跳出
            break;
    }
}

countDown内部实现流程:

  1. 尝试释放锁tryReleaseShared，实现计数-1
  • 若计数已经小于0，则直接返回false
  • 否则执行计数(AQS的state)减一
  • 若减完之后，state==0，表示没有线程占用锁，即释放成功，然后就需要唤醒被阻塞的线程了
  1. 释放并唤醒阻塞线程 doReleaseShared
  • 如果队列为空，即表示没有线程被阻塞（也就是说没有线程调用了 CountDownLatch#wait()方法），直接退出
  • 头结点如果为SIGNAL, 则依次唤醒头结点下个节点上关联的线程，并出队

注意：即CountDownLatch计数为0之后，所有被阻塞的线程都会被唤醒，且彼此相对独立，不会出现独占锁阻塞的问题

3. await() 阻塞等待计数为0

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);
}


// 计数为0时，表示获取锁成功
protected int tryAcquireShared(int acquires) {
    return (getState() == 0) ? 1 : -1;
}

// 阻塞，并入队
private void doAcquireSharedInterruptibly(int arg)
    throws InterruptedException {
    final Node node = addWaiter(Node.SHARED); // 入队
    boolean failed = true;
    try {
        for (;;) {
            // 获取前驱节点
            final Node p = node.predecessor();
            if (p == head) {
                int r = tryAcquireShared(arg);
                if (r >= 0) {
                    // 获取锁成功，设置队列头为node节点
                    setHeadAndPropagate(node, r);
                    p.next = null; // help GC
                    failed = false;
                    return;
                }
            }
            if (shouldParkAfterFailedAcquire(p, node) // 线程挂起
              && parkAndCheckInterrupt())
                throw new InterruptedException();
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

阻塞的内部实现逻辑

  1. 判断state计数是否为0，不是，则直接放过执行后面的代码
  2. 大于0，则表示需要阻塞等待计数为0
  3. 当前线程封装Node对象，进入阻塞队列
  4. 然后就是循环尝试获取锁，直到成功（即state为0）后出队，继续执行线程后续代码

1.3、使用注意

  • 在创建实例时，必须指定初始的计数值，且应大于0
  • 必须有线程中显示的调用了countDown()计数-1方法；必须有线程显示调用了await()方法（没有这个就没有必要使用CountDownLatch了）
  • 由于await()方法会阻塞到计数为0，如果在代码逻辑中某个线程漏掉了计数-1，导致最终计数一直大于0，直接导致死锁了；
  • 鉴于上面一点，更多的推荐 await(long, TimeUnit)来替代直接使用await()方法，至少不会造成阻塞死只能重启的情况
  • 允许多个线程调用await方法，当计数为0后，所有被阻塞的线程都会被唤醒

1.4、使用场景

  • 确保某个计算在其需要的所有资源都被初始化之后才继续执行。
  • 确保某个服务在其依赖的所有其他服务都已启动后才启动。
  • 等待知道某个操作的所有者都就绪在继续执行。

1.5、示例

　　有5个运动员赛跑，为了公平所有运动员需要同时起跑。同时，当最后一个运动员跑完之后，比赛结束。 

    public static void main(String[] args) {
        //所有线程阻塞，然后统一开始
        CountDownLatch begin = new CountDownLatch(1);
        //主线程阻塞，直到所有分线程执行完毕
        CountDownLatch end = new CountDownLatch(5);
        for(int i = 0; i < 5; i++){
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        begin.await();
                        System.out.println(LocalDateTime.now()+":"+Thread.currentThread().getName() + " 起跑");
                        Thread.sleep(new Random().nextInt(2000));
                        System.out.println(LocalDateTime.now()+":"+Thread.currentThread().getName() + " 到达终点");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    finally {
                        end.countDown();
                    }

                }
            });

            thread.start();
        }

        try {
            System.out.println(LocalDateTime.now()+":"+"1秒后统一开始");
            Thread.sleep(1000);
            begin.countDown();

            end.await();
            System.out.println(LocalDateTime.now()+":"+"停止比赛");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

结果

2019-02-12T16:51:38.903:1秒后统一开始
2019-02-12T16:51:39.904:Thread-1 起跑
2019-02-12T16:51:39.904:Thread-4 起跑
2019-02-12T16:51:39.904:Thread-3 起跑
2019-02-12T16:51:39.904:Thread-2 起跑
2019-02-12T16:51:39.904:Thread-0 起跑
2019-02-12T16:51:40.035:Thread-0 到达终点
2019-02-12T16:51:40.484:Thread-2 到达终点
2019-02-12T16:51:41.087:Thread-4 到达终点
2019-02-12T16:51:41.215:Thread-3 到达终点
2019-02-12T16:51:41.287:Thread-1 到达终点
2019-02-12T16:51:41.288:停止比赛

 

示例二、

package com.github.bjlhx15.common.thread.juc.collection;

import java.util.concurrent.CountDownLatch;

public class CountDownLatchTest {
    // 自定义工作线程
    private static class Worker extends Thread {
        private CountDownLatch countDownLatch;

        public Worker(CountDownLatch countDownLatch) {
            this.countDownLatch = countDownLatch;
        }

        @Override
        public void run() {
            super.run();

            try {
                countDownLatch.await();
                System.out.println(Thread.currentThread().getName() + "开始执行");
                // 工作线程开始处理，这里用Thread.sleep()来模拟业务处理
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName() + "执行完毕");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(1);

        for (int i = 0; i < 3; i++) {
            System.out.println("创建工作线程" + i);
            Worker worker = new Worker(countDownLatch);
            worker.start();
        }

        // 工作线程需要等待主线程准备操作完毕才可以执行，这里用Thread.sleep()来模拟准备操作
        Thread.sleep(1000);
        System.out.println("主线程准备完毕");

        countDownLatch.countDown();
    }
}

输出

创建工作线程0
创建工作线程1
创建工作线程2
主线程准备完毕
Thread-0开始执行
Thread-2开始执行
Thread-1开始执行
Thread-2执行完毕
Thread-1执行完毕
Thread-0执行完毕

　　自定义的工作线程必须要等主线程准备完毕才可以执行，可以使用CountDownLatch类来帮助我们完成。从程序的执行结果中也可以看出，3个工作线程确实是在主线程准备完毕后才开始执行。

转载于:https://www.cnblogs.com/bjlhx/p/10365871.html

dilv4062
关注
【高并发】JUC中等待多线程完成的工具类CountDownLatch
九师兄
11-27 429
添加链接描述假如有这样一个需求，当我们需要解析一个Excel里多个sheet的数据时，可以考虑使用多线程，每个线程解析一个sheet里的数据，等到所有的sheet都解析完之后，程序需要统计解析总耗时。分析一下：解析每个sheet耗时可能不一样，总耗时就是最长耗时的那个操作。//休眠时间（秒） int sleepSeconds;System . out . println(startTime + "," + ct . getName() + ",开始处理!");try {
【Java多线程】JUC之深入队列同步器(AQS)（四）CountDownLatch(闭锁)源码解析
墩墩分墩
12-27 276
俗称：(同步计数器/闭锁)，是AQS共享锁的具体实现，可以使一个线程等待其他线程全部执行完毕后再执行。 类似join()的效果。 场景：主要用来解决一个线程等待 N 个线程的场景。通常用来汇总各个线程执行后的结果 CountDownLatch内部通过一个计数器来控制等待线程数，该计数器的操作是原子操作，即同时只能有一个线程去更新该计数器。 调用await()方法的线程会一直处于阻塞状态，直到其他线程调用countDown()使当前计数器的值变为 0，每次调用countDown()方法计数器的值减1。当计数
如何实现某个线程在其他线程执行完毕之后再执行?
裸奔的小强的博客
04-19 5492
我们都知道, 在使用多线程编程的时候,每个线程运行的顺序都是随机的, 它由CPU的线程调度机制决定执行哪个线程; 我们可以看看正常使用多线程编程时程序的运行顺序: import java.util.ArrayList; import java.util.List; import java.util.concurrent.Callable; import java.util.concurrent.C...
JUC（一）CountDownlatch：如何让一些线程等待另外一些线程执行完再执行
weixin_43082657的博客
05-18 517
一、案例分析： 1.假如我们现在有一个需求： （1）全班10个同学出游，司机要等待这10个同学都上车之后才出发 （2）假如我们要通过50个线程，打印5000以内的偶数，最后计算总共消耗的时间（代码实现附在文末） （3）线程a计算公司支出，线程b计算公司盈利，线程c等待ab执行完成后计算公司利润。 2.需求实现： 我们实现需求1吧，其他自行实现，欢迎尝试。 按照正常写法会是这样的： public class juctest { /** * author:liganggang
JUC之花里胡哨CountDownLatch
kaleldo的博客
03-24 152
前言 CountDownLatch允许一个或多个线程等待其他线程完成操作。定义CountDownLatch的时候，需要传入一个正数来初始化计数器（虽然传入0也可以，但这样的话CountDownLatch没什么实际意义）。其countDown方法用于递减计数器，await方法会使当前线程阻塞，直到计数器递减为0。所以CountDownLatch常用于多个线程之间的协调工作。 示例 假设我们现在有...
【Java多线程】ReentrantLock
Super_Powerbank的博客
02-05 636
文章目录ReentrantLockReentrantLock（类）与synchronized（关键字）的区别ReentrantLock的使用重入锁与不可重入锁公平锁非公平锁生产者消费者模型 ReentrantLock 在实现线程同步时，大多情况下使用的是Synchronized关键字实现，但是Synchronized的锁太过封闭，获得锁和释放锁都是系统自动的。所以为了更灵活的操作，在JDK1.5版本之后，就诞生了Lock接口以及其实现类ReentrantLock。 lock接口也是对资源上锁的一种工具，它
JUC高并发编程
hanlin
10-05 160
JUC概述 1.1 JUC简介 java.util.concurrent包名的简写,是关于并发编程的API 与JUC相关的有三个包：java.util.concurrent、java.util.concurrent.atomic、java.util.concurrent.locks 1.2 进程和线程 进程：系统中一个正在运行的应用程序；一个程序就是一个进程；进程操作系统资源分配的最小单位 线程：系统分配处理器时间资源的基本单位；进程之内独立执行的一个单元执行流。线程是程序执行的最小单位 1.3 线
JUC学习 - CountDownLatch
TyuIn的博客
11-26 305
一、JUC中的CountDownLatch 思考一个需求 假如有这样一个需求，当我们需要解析一个Excel里多个sheet的数据时，可以考虑使用多线程，每个线程解析一个sheet里的数据，等到所有的sheet都解析完之后，程序需要统计解析总耗时。分析一下：解析每个sheet耗时可能不一样，总耗时就是最长耗时的那个操作。 我们能够想到的最简单的做法是使用join，代码如下： public class ThreadTest { public static class T extends T
【Java多线程】JUC之显示锁(Lock)与初识AQS(队列同步器)
墩墩分墩
11-22 1356
**锁机制用于保证操作的原子性、可见性、顺序性**。`JDK1.5的concurrent并发包`中新增了`Lock接口以及相关实现类来实现锁功能`，最明显的特性就是需要显式的申请锁和释放锁。比synchronized更加灵活。 >显示锁的释放锁的操作一定要放到finally块中，否则可能会因为异常导致锁永远无法释放！这是显式锁最明显的缺点。
java高并发系列 - 第16天：JUC中等待多线程完成的工具类CountDownLatch，必备技能
专搞技术的小兔子
08-07 153
CountDownLatch称之为闭锁，它可以使一个或一批线程在闭锁上等待，等到其他线程执行完相应操作后，闭锁打开，这些等待的线程才可以继续执行。确切的说，闭锁在内部维护了一个倒计数器。通过该计数器的值来决定闭锁的状态，从而决定是否允许等待的线程继续执行。常用方法：public CountDownLatch(int count)：构造方法，count表示计数器的值，不能小于0，否者会报异常。
多线程如何等待所有子线程一起完成任务后再执行主线程
weixin_44860609的博客
01-08 4068
多线程如何等待所有子线程一起完成任务后再执行主线程 1、使用线程类自带的join方法，将子线程加入到主线程，在子线程执行完之后，在执行主线程逻辑。 public static void joinDemo() throws InterruptedException { System.out.println("=========Test with join====="); JoinWorker worker1 = new JoinWorker("worke
006-多线程-JUC线程池-并发测试程序
dilv4062的博客
08-06 241
一、java代码模拟并发 1.1、一次并发 单次并发测试 1、使用CountDownLatch 　　等待一个或多个线程一起执行 　　详细参看：007-多线程-锁-JUC锁-CountDownLatch-闭锁【允许一个或多个线程，等待其他一组线程完成操作，再继续执行】 示例代码 @Test public void poolCountDownLatch()...
【java】【多线程】等待开启的多个线程都执行完成，再做事情，怎么实现
weixin_33964094的博客
08-10 685
今天在controller中写一个接口用来测试模拟多个请求同时到达 下订单的情况， 怎么能有效保证高并发下的库存和销量的一致性呢？【具体实现方法：https://www.cnblogs.com/sxdcgaq8080/p/9454161.html】 ==== 那么好，在这个接口中，开启多线程模拟了多个用户请求同时到达的状况，现在想在多个线程都执行完了以后再统一返回结果给前台，哪些请求成功了，哪些请...
【java】【多线程】等待开启的多个线程都执行完成，再做事情，怎么实现 《转》
whaosy的专栏
06-10 753
本文转自:https://www.cnblogs.com/sxdcgaq8080/p/9456006.html 怎么能有效保证高并发下的库存和销量的一致性呢？【具体实现方法：https://www.cnblogs.com/sxdcgaq8080/p/9454161.html】 ==== 那么好，在这个接口中，开启多线程模拟了多个用户请求同时到达的状况，现在想在多个线程都执行完了以后再统一返回结果给前台，哪些请求成功了，哪些请求失败了。 ==== 所以现在的需求是怎么能实现 等待多个线...
日常bug记录，easyexcel导入报错convert data ... to class java.math.BigDecimal error
mm
11-11 97
排查发现实体类中有BigDecimal属性，然而数据中这个属性为null，进行转换时报错。在实体类上加上自定义转换器。解决方法：自定义转换器类。
SpringBoot 实现图片加水印
最新发布
心猿意码
11-11 208
通过上述步骤，我们可以在SpringBoot项目中实现一个简单的图片加水印功能。当然，实际应用中可能需要更复杂的水印处理，比如水印图片、调整水印位置等，可以根据需求进行相应的扩展和优化。
刷题---顺序表算法题
weixin_63997543的博客
11-11 253
顺序算法题----力扣刷题
JAVA-01-变量
LJH_laura_li的博客
11-08 460
在方法、构造函数或块内部定义的变量。
Java并发编程-JUC-CountDownLatch 倒计数门闩器-等待多线程完成再放行 -一次性使用...
06-08
好的，您想了解关于Java并发编程中的CountDownLatch吗？ CountDownLatch是Java并发编程中非常重要的一个工具类，它可以让某个线程等待其他线程完成后再继续执行。它的作用类似于倒计时门闩，当count值减为0时，所有等待者都会被唤醒。 CountDownLatch是一次性的，也就是说，它的计数器只能使用一次。如果需要重复使用，可以考虑使用CyclicBarrier。 在使用CountDownLatch时，我们需要先创建一个CountDownLatch对象，并指定计数器的初始值。然后在需要等待的线程中调用await()方法进行等待，同时在其他线程中调用countDown()方法进行计数器的减1操作。 举个例子，假设我们有一个需求：主线程需要等待两个子线程完成后再执行。那么可以这样编写代码： ```java import java.util.concurrent.CountDownLatch; public class CountDownLatchDemo { public static void main(String[] args) throws InterruptedException { CountDownLatch countDownLatch = new CountDownLatch(2); new Thread(() -> { System.out.println(Thread.currentThread().getName() + "执行开始"); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "执行完毕"); countDownLatch.countDown(); }, "线程1").start(); new Thread(() -> { System.out.println(Thread.currentThread().getName() + "执行开始"); try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "执行完毕"); countDownLatch.countDown(); }, "线程2").start(); System.out.println(Thread.currentThread().getName() + "等待子线程执行完毕"); countDownLatch.await(); System.out.println(Thread.currentThread().getName() + "所有子线程执行完毕，继续执行主线程"); } } ``` 在上面的例子中，我们首先创建了一个计数器初始值为2的CountDownLatch对象，然后创建了两个线程分别进行一些操作，并在操作结束后调用countDown()方法进行计数器减1操作。在主线程中，我们调用await()方法进行等待，直到计数器减为0时，主线程才会继续执行。 希望能够对您有所帮助！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值