备注：博客园的markDown格式支持的特别不友好。也欢迎查看我的csdn的此篇文章链接：CountDownLatch、CyclicBarrier和Semaphore 使用示例及原理

CountDownLatch

CountDownLatch用户监听某些初始化操作，并且线程进行阻塞，等初始化执行完毕后，通知主线程继续工作执行。

CountDownLatch 使用示例

使用示例，线程t3 要等待t1和t2执行完毕才执行：

  1. /**
  2.  * @Description: CountDownLatch 等待和唤醒
  3.  * @Author: wangmeng
  4.  * @Date: 2018/12/16-16:38
  5.  */
  6. public class UseCountDownLatch {
  8.     public static void main(String[] args) {
  9.         CountDownLatch countDownLatch = new CountDownLatch(2);
  10.         Thread t1 = new Thread(new Runnable() {
  11.             @Override
  12.             public void run() {
  13.                 System.out.println("进入t1线程。。。");
  14.                 try {
  15.                     TimeUnit.SECONDS.sleep(3);
  16.                 } catch (InterruptedException e) {
  17.                     e.printStackTrace();
  18.                 }
  20.                 System.out.println("t1线程初始化完毕，通知t3线程继续操作！");
  21.                 countDownLatch.countDown();
  22.             }
  23.         }, "t1");
  25.         Thread t2 = new Thread(new Runnable() {
  26.             @Override
  27.             public void run() {
  28.                 System.out.println("进入t2线程。。。");
  29.                 try {
  30.                     TimeUnit.SECONDS.sleep(4);
  31.                 } catch (InterruptedException e) {
  32.                     e.printStackTrace();
  33.                 }
  35.                 System.out.println("t2线程初始化完毕，通知t3线程继续操作！");
  36.                 countDownLatch.countDown();
  37.             }
  38.         }, "t2");
  40.         Thread t3 = new Thread(new Runnable() {
  41.             @Override
  42.             public void run() {
  43.                 System.out.println("进入t3 线程，并且等待...");
  44.                 try {
  45.                     countDownLatch.await();
  46.                 } catch (InterruptedException e) {
  47.                     e.printStackTrace();
  48.                 }
  50.                 System.out.println("t3线程进行后续的执行操作...");
  51.             }
  52.         }, "t3");
  54.         t1.start();
  55.         t2.start();
  56.         t3.start();
  57.     }
  58. }

打印结果：

  1. 进入t1线程。。。
  2. 进入t3 线程，并且等待...
  3. 进入t2线程。。。
  4. t1线程初始化完毕，通知t3线程继续操作！
  5. t2线程初始化完毕，通知t3线程继续操作！
  6. t3线程进行后续的执行操作...

CountDownLatch 源码解读

其实CountDownLatch用的底层原理就是AQS， 可以参考：(AQS原理详解)。AQS全局维护的有一个volatile修饰的state字段，当state为0时就会通知countDownLatch等待线程执行。

这也就是所以我们在new CountDownLatch(int n) 时指定的参数，n为多少，也就是要调用多少次countDown()方法。

  1. public void await() throws InterruptedException { }; //调用await()方法的线程会被挂起，它会等待直到count值为0才继续执行
  2. public boolean await(long timeout, TimeUnit unit) throws InterruptedException { }; //和await()类似，只不过等待一定的时间后count值还没变为0的话就会继续执行
  3. public void countDown() { }; //将count值减1

看看await()方法, 其底层调用的就是AQS中的getState方法，通过判断state是否为0来决定是否唤醒等待的线程。

如果不为0则调用Unsafe中的park方法进行自旋，直到state==0时才继续往下执行（唤醒等待的线程）。

  1. public void await() throws InterruptedException {
  2.     //调用AQS中的方法
  3.      sync.acquireSharedInterruptibly(1);
  4.  }
  6. public final void acquireSharedInterruptibly(int arg)
  7.             throws InterruptedException {
  8.     if (Thread.interrupted())
  9.         throw new InterruptedException();
  10.     if (tryAcquireShared(arg) < 0)
  11.         doAcquireSharedInterruptibly(arg);
  12. }
  14. //CountDownLatch中的方法，获取state值
  15. protected int tryAcquireShared(int acquires) {
  16.         return (getState() == 0) ? 1 : -1;
  17.  }
  19. //当AQS中的state不为0就会执行此方法，这个方法也就是让线程等待。使用直到state==0才结束循环。
  20. private void doAcquireSharedInterruptibly(int arg)
  21.         throws InterruptedException {
  22.         final Node node = addWaiter(Node.SHARED);
  23.         boolean failed = true;
  24.         try {
  25.             for (;;) {
  26.                 final Node p = node.predecessor();
  27.                 if (p == head) {
  28.                     int r = tryAcquireShared(arg);
  29.                     if (r >= 0) {
  30.                         setHeadAndPropagate(node, r);
  31.                         p.next = null; // help GC
  32.                         failed = false;
  33.                         return;
  34.                     }
  35.                 }
  36.                 if (shouldParkAfterFailedAcquire(p, node) &&
  37.                     parkAndCheckInterrupt())
  38.                     throw new InterruptedException();
  39.             }
  40.         } finally {
  41.             if (failed)
  42.                 cancelAcquire(node);
  43.         }
  44.     }

看到上面await方法了，那么countDown就可以直接猜出来了，无外乎就是使得AQS中的state通过CAS操作进行减一，如下：

  1. protected boolean tryReleaseShared(int releases) {
  2.             // Decrement count; signal when transition to zero
  3.             for (;;) {
  4.                 int c = getState();
  5.                 if (c == 0)
  6.                     return false;
  7.                 int nextc = c-1;
  8.                 if (compareAndSetState(c, nextc))
  9.                     return nextc == 0;
  10.             }
  11.         }

CyclicBarrier

CyclicBarrier是回环栅栏的概念，多线程来的进行阻塞，等待某一个临界值条件满足后，同时执行。

假设有一个场景：每个线程代表一个跑步运动员，当运动员都准备好后，才一起出发，只要有一个人没有准备好，大家都等待。

CyclicBarrier 应用实例

  1. /**
  2.  * @Description: 测试CyclicBarrier
  3.  * @Author: wangmeng
  4.  * @Date: 2018/12/16-17:05
  5.  */
  6. public class UseCyclicBarrier {
  8.     //模拟运动员的类。
  9.     static class Runner implements Runnable {
  11.         private String name;
  13.         private CyclicBarrier cyclicBarrier;
  15.         @Override
  16.         public void run() {
  17.             try {
  18.                 System.out.println("运动员：" + this.name + "进行准备工作！");
  19.                 TimeUnit.SECONDS.sleep((new Random().nextInt(5)));
  20.                 System.out.println("运动员：" + this.name + "准备完成！");
  21.                 this.cyclicBarrier.await();
  22.             } catch (Exception e) {
  23.                 e.printStackTrace();
  24.             }
  26.             System.out.println("运动员" + this.name + "开始起跑！！！");
  27.         }
  29.         public Runner(String name, CyclicBarrier cyclicBarrier) {
  30.             this.name = name;
  31.             this.cyclicBarrier = cyclicBarrier;
  32.         }
  33.     }
  35.     public static void main(String[] args) {
  36.         CyclicBarrier cyclicBarrier = new CyclicBarrier(3);
  37.         ExecutorService executorPools = Executors.newFixedThreadPool(3);
  39.         executorPools.submit(new Thread(new Runner("张三", cyclicBarrier)));
  40.         executorPools.submit(new Thread(new Runner("李四", cyclicBarrier)));
  41.         executorPools.submit(new Thread(new Runner("王五", cyclicBarrier)));
  43.         executorPools.shutdown();
  44.     }
  45. }

打印的结果：

  1. 运动员：张三进行准备工作！
  2. 运动员：李四进行准备工作！
  3. 运动员：王五进行准备工作！
  4. 运动员：张三准备完成！
  5. 运动员：王五准备完成！
  6. 运动员：李四准备完成！
  7. 运动员李四开始起跑！！！
  8. 运动员张三开始起跑！！！
  9. 运动员王五开始起跑！！！

可以看到三个线程都是先执行完初始化操作，然后才一起唤醒执行后续的操作。

CyclicBarrier 源码解读

CyclicBarrier是通过ReentrantLock和Condition来实现的。

  1. private int dowait(boolean timed, long nanos)
  2.     throws InterruptedException, BrokenBarrierException,
  3.            TimeoutException {
  4.     final ReentrantLock lock = this.lock;
  5.     // 锁住
  6.     lock.lock();
  7.     try {
  8.         // 当前代
  9.         final Generation g = generation;
  10.         // 如果这代损坏了，抛出异常
  11.         if (g.broken)
  12.             throw new BrokenBarrierException();
  14.         // 如果线程中断了，抛出异常
  15.         if (Thread.interrupted()) {
  16.             // 将损坏状态设置为 true
  17.             // 并通知其他阻塞在此栅栏上的线程
  18.             breakBarrier();
  19.             throw new InterruptedException();
  20.         }
  21.         // 获取下标
  22.         int index = --count;
  23.         // 如果是 0 ,说明到头了
  24.         if (index == 0) { // tripped
  25.             boolean ranAction = false;
  26.             try {
  27.                 final Runnable command = barrierCommand;
  28.                 // 执行栅栏任务
  29.                 if (command != null)
  30.                     command.run();
  31.                 ranAction = true;
  32.                 // 更新一代,将 count 重置,将 generation 重置.
  33.                 // 唤醒之前等待的线程
  34.                 nextGeneration();
  35.                 // 结束
  36.                 return 0;
  37.             } finally {
  38.                 // 如果执行栅栏任务的时候失败了,就将栅栏失效
  39.                 if (!ranAction)
  40.                     breakBarrier();
  41.             }
  42.         }
  44.         for (;;) {
  45.             try {
  46.                 // 如果没有时间限制,则直接等待,直到被唤醒
  47.                 if (!timed)
  48.                     trip.await();
  49.                 // 如果有时间限制,则等待指定时间
  50.                 else if (nanos > 0L)
  51.                     nanos = trip.awaitNanos(nanos);
  52.             } catch (InterruptedException ie) {
  53.                 // g == generation >> 当前代
  54.                 // ! g.broken >>> 没有损坏
  55.                 if (g == generation && ! g.broken) {
  56.                     // 让栅栏失效
  57.                     breakBarrier();
  58.                     throw ie;
  59.                 } else {
  60.                     // 上面条件不满足,说明这个线程不是这代的.
  61.                     // 就不会影响当前这代栅栏执行逻辑.所以,就打个标记就好了
  62.                     Thread.currentThread().interrupt();
  63.                 }
  64.             }
  65.             // 当有任何一个线程中断了,会调用 breakBarrier 方法.
  66.             // 就会唤醒其他的线程,其他线程醒来后,也要抛出异常
  67.             if (g.broken)
  68.                 throw new BrokenBarrierException();
  69.             // g != generation >>> 正常换代了
  70.             // 一切正常,返回当前线程所在栅栏的下标
  71.             // 如果 g == generation，说明还没有换代，那为什么会醒了？
  72.             // 因为一个线程可以使用多个栅栏，当别的栅栏唤醒了这个线程，就会走到这里，所以需要判断是否是当前代。
  73.             // 正是因为这个原因，才需要 generation 来保证正确。
  74.             if (g != generation)
  75.                 return index;
  76.             // 如果有时间限制,且时间小于等于0,销毁栅栏,并抛出异常
  77.             if (timed && nanos <= 0L) {
  78.                 breakBarrier();
  79.                 throw new TimeoutException();
  80.             }
  81.         }
  82.     } finally {
  83.         lock.unlock();
  84.     }
  85. }

用上面的示例总结一下CyclicBarrier的await方法实现，假设线程thread1和线程thread2都执行到CyclicBarrier的await()，都进入dowait(boolean timed, long nanos)，thread1先获取到独占锁，执行到--count的时，index等于1，所以进入下面的for循环，接着执行trip.await()，进入await()方法，执行Node node = addConditionWaiter()将当前线程构造成Node节点并加入到Condition等待队列中，然后释放获取到的独占锁，当前线程进入阻塞状态；此时，线程thread2可以获取独占锁，继续执行--count，index等于0，所以先执行command.run()，输出myThread，然后执行nextGeneration()，nextGeneration()中trip.signalAll()只是将Condition等待队列中的Node节点按之前顺序都转移到了AQS同步队列中，这里也就是将thread1对应的Node节点转移到了AQS同步队列中，thread2执行完nextGeneration()，返回return 0之前，细看代码还需要执行lock.unlock()，这里会执行到ReentrantLock的unlock()方法，最终执行到AQS的unparkSuccessor(Node node)方法，从AQS同步队列中的头结点开始释放节点，唤醒节点对应的线程，即thread1恢复执行。

如果有三个线程thread1、thread2和thread3，假设线程执行顺序是thread1、thread2、thread3，那么thread1、thread2对应的Node节点会被加入到Condition等待队列中，当thread3执行的时候，会将thread1、thread2对应的Node节点按thread1、thread2顺序转移到AQS同步队列中，thread3执行lock.unlock()的时候，会先唤醒thread1，thread1恢复继续执行，thread1执行到lock.unlock()的时候会唤醒thread2恢复执行。

更多可参考：并发编程之 CyclicBarrier 源码分析

CountdownLatch和CyclicBarrier的区别

1、CountDownLatch简单的说就是一个线程等待，直到他所等待的其他线程都执行完成并且调用countDown()方法发出通知后，当前线程才可以继续执行。

2、CyclicBarrier是所有线程都进行等待，直到所有线程都准备好进入await()方法之后，所有线程同时开始执行！

3、CountDownLatch的计数器只能使用一次。而CyclicBarrier的计数器可以使用reset() 方法重置。所以CyclicBarrier能处理更为复杂的业务场景，比如如果计算发生错误，可以重置计数器，并让线程们重新执行一次。

Semaphore

Semaphore翻译成字面意思为 信号量，Semaphore可以控同时访问的线程个数，通过 acquire() 获取一个许可，如果没有就等待，而 release() 释放一个许可。

关于限流的其他方式可以参考我另一篇博文：限流的简单使用及学习

相关概念：

  • PV（page view）网站的总访问量，页面浏览量或点击量，用户每刷新一次就会被记录一次。
  • UV（unique Visitor）访问网站的一台电脑客户端为一个访客。一般来讲时间上以00:00-24:00之内相同ip的客户端只记录。
  • QPS（query per second）即每秒查询数，qps很大程度上代表了系统业务上的繁忙程度，每次请求的背后，可能对应着多次磁盘I/O，多次网络请求，多个cpu时间片等。我们通过qps可以非常直观的了解当前系统业务情况，一旦当前qps超过所设定的预警阀值，可以考虑增加机器对集群扩容，以免压力过大导致宕机，可以根据前期的压力测试得到估值，在结合后期综合运维情况，估算出阀值。
  • RT（response time）请求的响应时间，这个指标非常关键，直接说明前端用户的体验，任何系统设计师都想降低rt时间。
  • 当然还涉及cpu、内存、网络、磁盘等情况，更细节的问题很多，如select、update、delete/ps等数据库层面的统计。
  • 容量评估：一般来说通过开发、运维、测试、以及业务等相关人员，综合出系统的一系列阀值，然后我们根据关键阀值如qps、rt等，对系统进行有效的变更。
  • 一般来讲，我们进行多轮压力测试以后，可以对系统进行峰值评估，采用所谓的80/20原则，即80%的访问请求将在20%的时间内达到。这样我们可以根据系统对应的PV计算出峰值qps。
  • 峰值qps= （总PV × 80%）/ （60 × 60 × 24 × 20%）
  • 然后在将总的峰值qps除以单台机器所能承受的最高的qps值，就是所需要机器的数量：机器数 = 总的峰值qps / 压测得出的单机极限qps
  • 当然不排除系统在上线前进行大型促销活动，或者双十一、双十二热点事件、遭受到DDos攻击等情况，系统的开发和运维人员急需要了解当前系统运行的状态和负载情况，一般都会有后台系统去维护。

Semaphore 使用示例：

  1. /**
  2.  * @Description:使用Semaphore模拟限流操作
  3.  * @Author: wangmeng
  4.  * @Date: 2018/12/16-18:30
  5.  */
  6. public class UseSemaphore {
  8.     public static void main(String[] args) {
  9.         ExecutorService threadPools = Executors.newFixedThreadPool(20);
  10.         //同一时间只能有5个线程执行
  11.         Semaphore semaphore = new Semaphore(5);
  13.         for (int i = 0; i < 20; i++) {
  14.             final int token = i;
  15.             Runnable run = new Runnable() {
  16.                 @Override
  17.                 public void run() {
  18.                     try {
  19.                         semaphore.acquire();
  21.                         //进行业务操作
  22.                         System.out.println("获得许可，执行操作..." + token);
  23.                         long sleepTime = (long)(Math.random() * 10000);
  24.                         Thread.sleep(sleepTime);
  25.                     } catch (InterruptedException e) {
  26.                         e.printStackTrace();
  27.                     } finally {
  28.                         semaphore.release();
  29.                     }
  30.                 }
  31.             };
  33.             threadPools.execute(run);
  34.         }
  36.         System.out.println("queue length: " + semaphore.getQueueLength());
  37.         threadPools.shutdown();
  38.     }
  39. }

原理也是使用AQS中的state变量。代码我就不贴了。

Semaphore原理可参见：https://juejin.im/post/5ae755366fb9a07ab508adc6

Semaphore 就是一个共享锁，通过设置 state 变量来实现对这个变量的共享。当调用 acquire 方法的时候，state 变量就减去一，当调用 release 方法的时候，state 变量就加一。当 state 变量为 0 的时候，别的线程就不能进入代码块了，就会在 AQS 中阻塞等待。

CountDownLatch、CyclicBarrier和Semaphore 使用示例及原理的更多相关文章

  1. CountDownLatch CyclicBarrier和 Semaphore

    CountDownLatch CyclicBarrier和 Semaphore 原理 基于AQS实现. 让需要的暂时阻塞的线程,进入一个死循环里面,得到某个条件后再退出循环,以此实现阻塞当前线程的效果 ...

  2. CountDownLatch, CyclicBarrier and Semaphore

    Reference: [1] http://shazsterblog.blogspot.co.uk/2011/12/comparison-of-countdownlatch.html CountDow ...

  3. Java并发包5--同步工具CountDownLatch、CyclicBarrier、Semaphore的实现原理解析

    前言: JUC中提供了很多同步工具类,比如CountDownLatch.CyclicBarrier.Semaphore等,都可以作用同步手段来实现多线程之间的同步效果 一.CountDownLatch ...

  4. 【Java多线程】JUC包下的工具类CountDownLatch、CyclicBarrier和Semaphore

    前言 JUC中为了满足在并发编程中不同的需求,提供了几个工具类供我们使用,分别是CountDownLatch.CyclicBarrier和Semaphore,其原理都是使用了AQS来实现,下面分别进行 ...

  5. Java中的并发工具类(CountDownLatch、CyclicBarrier、Semaphore、Exchanger)

    在JDK的并发包里提供了很多有意思的并发工具类.CountDownLatch.CyclicBarrier和Semaphore 工具类提供了一种并发流程控制的手段,Exchanger 工具类则提供了在线 ...

  6. Java中的并发工具类：CountDownLatch、CyclicBarrier和Semaphore

    在java 1.5中,提供了一些非常有用的辅助类来帮助我们进行并发编程,比如CountDownLatch,CyclicBarrier和Semaphore,今天我们就来学习一下这三个辅助类的用法. 一. ...

  7. 并发编程学习笔记(10)----并发工具类CyclicBarrier、Semaphore和Exchanger类的使用和原理

    在jdk中,为并发编程提供了CyclicBarrier(栅栏),CountDownLatch(闭锁),Semaphore(信号量),Exchanger(数据交换)等工具类,我们在前面的学习中已经学习并 ...

  8. CountDownLatch/CyclicBarrier/Semaphore 使用过吗？

    CountDownLatch/CyclicBarrier/Semaphore 使用过吗?下面详细介绍用法: 一,(等待多线程完成的)CountDownLatch  背景; countDownLatch ...

  9. Java并发（8）：CountDownLatch、CyclicBarrier、Semaphore、Callable、Future

    CountDownLatch.CyclicBarrier.Semaphore.Callable.Future  都位于java.util.concurrent包下,其中CountDownLatch.C ...

随机推荐

  1. [ 低危 ] mt网CRLF

    漏洞: xxx.meituan.com/%0d%0aevilheadername:%20inject_by_whoamisb 原理猜测: 收到xxx二级域名的时候,会location跳转到该域名(这是 ...

  2. Spring Boot 静态资源访问原理解析

    一.前言 springboot配置静态资源方式是多种多样,接下来我会介绍其中几种方式,并解析一下其中的原理. 二.使用properties属性进行配置 应该说 spring.mvc.static-pa ...

  3. 涂鸦之作WanAndroid第三方APP

    Wan Android App Introduction 我的涂鸦之作,正如名字一样 这个一个WanAndroid 的第三方Android客户端,采用MVP架构+Kotlin语言+一大堆轮子.现在的代 ...

  4. [Web]flask-excel实现excel文件下载的前后端实现

    之前同事写了前端表格导出的功能, 前后端逻辑没有梳理, 导致后端代码十分臃肿. 接手之后, 重新选择了前端table插件, 从jqxGrid变更为bootstrapTable. 本来想依赖集成的tab ...

  5. Codeforces.97D.Robot in Basement(bitset 模拟)

    题目链接 (ozr attack) 考虑怎么暴力,就是先在所有非障碍格子上全放上机器人,然后枚举每一步,枚举每个机器人移动这一步,直到所有机器人都在出口位置.复杂度是\(O(nmk)\)的. 怎么优化 ...

  6. 潭州课堂25班：Ph201805201 爬虫高级 第十一课 Scrapy-redis分布 项目实战 (课堂笔

  7. linux screen 最简单的五个用法

    1.创建新的虚拟终端 screen 2.离开虚拟终端(不关闭) ctrl + a d 3.查看所有正在运行的虚拟终端 screen -ls 4.进入某一个虚拟终端 screen -r id 5.退出虚 ...

  8. MySQL（四）

    分组 按照字段分组,表示此字段相同的数据会被放到一个组中 分组后,只能查询出相同的数据列,对于有差异的数据列无法出现在结果集中 可以对分组后的数据进行统计,做聚合运算 语法: select 列1,列2 ...

  9. 登录页面加密token和盐的作用

    盐: 可以说盐是作用于注册,盐就是将用户输入的原始密码,加密后存进数据库,然后把盐(实际上是随机字符串)也存进数据库 Map<String, String> map = new HashM ...

  10. 一道c++面试题 输入一个维度，逆时针打印出一个指定的矩阵

    题目:逆时针打印矩阵元素 #include <stdio.h> #include <malloc.h> int main() { int dimension; int *p; ...