笔者是广州的java程序员，刚毕业半年，工作之余写博客，如果觉得我的文章写得不错，可以关注我的微信公众号（J2彬彬），里面会有更多精彩内容。从2018年8月份开始写博客，希望日后写出更多通俗易懂的技术文章与大家一同分享。
talk is cheap,show me the code
JUC其实是属于线程知识的中高级部分，所以也是面试中面试官喜欢问的一块知识点，这块知识也能比较看出一个程序员的功底，今天笔者就跟大家讲讲CountDownLatch，CyclicBarrier，Semaphore这些知识点。大家在看到这些知识的时候，千万不要一上来就抠细节，首先应该弄明白这些知识点时是干什么用的，用来解决什么问题，适合应用于什么样的业务场景。如果这些东西都没搞清楚就学，那么你学完很快就会忘掉。
之前笔者也发过一些关于JUC方面的知识，但也就是一些Demo代码，并没有细究，今天就是带领大家：入虎穴，得虎子。
闭锁CountDownLatch
如果把多个线程比喻成运动员，CountDownLatch相当于枪声发令员，枪声未响，所有线程都处于等待状态，当CountDownLatch计数器变为0时
相当于枪声发出，这时所有线程一同奔跑。与集齐七颗龙珠便可召唤神龙有异曲同工之妙。
1package com.bingo.thread.juc;
2
3/**
4 * Created with IntelliJ IDEA.
5 * Description: 倒时计数器（也叫闭锁）
6 * User: bingo
7 * Date: 2018-11-25
8 * Time: 11:16
9 */
10import java.util.concurrent.CountDownLatch;
11import java.util.concurrent.ExecutorService;
12import java.util.concurrent.Executors;
13
14public class CountDownLatchDemo {
15
16 public static void main(String[]args) throws InterruptedException{
17 final CountDownLatch startGate=new CountDownLatch(1);
18 final CountDownLatch endGate=new CountDownLatch(5);
19 //线程池
20 ExecutorService exce=Executors.newCachedThreadPool();
21 //创建5个线程
22 for(int i=1;i<=5;i++){
23 final int num=i;
24 Thread thread =new Thread(new Runnable() {
25 public void run() {
26 try {
27 System.out.println(num+"号选手准备就绪,等待裁判员哨声响起..");
28 //相当于同步锁Synchronized中的await()方法
29 startGate.await();
30 try {
31 Thread.sleep((long) (Math.random()*10000));
32 } catch (InterruptedException e) {
33 e.printStackTrace();
34 }
35 System.out.println(num+"号选手到达终点..");
36 } catch (InterruptedException e) {
37 e.printStackTrace();
38 }
39 finally{
40 //相当于同步锁Synchronized中的notify()方法,区别在于countDown需要执行5次后才能唤醒await()
41 endGate.countDown();
42 }
43 }
44 });
45 exce.execute(thread);
46 }
47 long start=System.nanoTime();
48 System.out.println("裁判员哨声响起..");
49 Thread.sleep(10000);
50 //唤醒执行startGate.await()的线程,让线程往下执行
51 startGate.countDown();
52 //等待被唤醒,主程序才能继续往下执行,线程中每次执行endGate.countDown()就减1,当为零的时候,主程序往下执行
53 endGate.await();
54 long end=System.nanoTime();
55 System.out.println("所有运动员到达终点,耗时:"+(end-start));
56 //关闭线程池
57 exce.shutdown();
58 }
59}
复制代码运行结果
1裁判员哨声响起..
21号选手准备就绪,等待裁判员哨声响起..
32号选手准备就绪,等待裁判员哨声响起..
43号选手准备就绪,等待裁判员哨声响起..
54号选手准备就绪,等待裁判员哨声响起..
65号选手准备就绪,等待裁判员哨声响起..
73号选手到达终点..
81号选手到达终点..
94号选手到达终点..
105号选手到达终点..
112号选手到达终点..
12所有运动员到达终点,耗时:17708083042
13
14Process finished with exit code 0
复制代码CountDownLatch实时系统中的使用场景
- 实现最大的并行性：有时我们想同时启动多个线程，实现最大程度的并行性。例如，我们想测试一个单例类。如果我们创建一个初始计数器为1的CountDownLatch，并让其他所有线程都在这个锁上等待，只需要调用一次countDown()方法就可以让其他所有等待的线程同时恢复执行。
- 开始执行前等待N个线程完成各自任务：例如应用程序启动类要确保在处理用户请求前，所有N个外部系统都已经启动和运行了。
- 死锁检测：一个非常方便的使用场景是你用N个线程去访问共享资源，在每个测试阶段线程数量不同，并尝试产生死锁。
循环屏障CyclicBarrier
CyclicBarrier与CountDownLatch非常相似，但是还是有一定区别。我们先看代码。
需求：人们（线程）先后到达餐桌上（某个点），但是不能动筷子（等待），所有人到齐才可以吃年夜饭（线程到齐才能一同执行）
1package com.bingo.thread.juc;
2
3import java.util.concurrent.BrokenBarrierException;
4import java.util.concurrent.CyclicBarrier;
5
6public class CyclicBarrierDemo {
7
8 public static void main(String[] args) {
9 final int count = 5;
10 final CyclicBarrier barrier = new CyclicBarrier(count, new Runnable() {
11 @Override
12 public void run() {
13 System.out.println("人到齐，大家一起吃年夜饭!");
14 }
15 });
16
17 // they do not have to start at the same time...
18 for (int i = 0; i < count; i++) {
19 new Thread(new Worker(i, barrier)).start();
20 }
21 }
22}
23
24class Worker implements Runnable {
25 final int id;
26 final CyclicBarrier barrier;
27
28 public Worker(final int id, final CyclicBarrier barrier) {
29 this.id = id;
30 this.barrier = barrier;
31 }
32
33 @Override
34 public void run() {
35 try {
36 System.out.println(this.id + "starts to run !");
37 Thread.sleep((long) (Math.random() * 10000));
38 System.out.println(this.id + "到桌 !");
39 this.barrier.await();
40 } catch (InterruptedException e) {
41 e.printStackTrace();
42 } catch (BrokenBarrierException e) {
43 e.printStackTrace();
44 }
45 }
46}
复制代码运行结果
10starts to run !
22starts to run !
31starts to run !
43starts to run !
54starts to run !
64到桌 !
73到桌 !
81到桌 !
92到桌 !
100到桌 !
11人到齐，大家一起吃年夜饭!
12
13Process finished with exit code 0
复制代码区别
- CountDownLatch减计数，CyclicBarrier加计数。
- CountDownLatch是一次性的，CyclicBarrier可以重用。
信号量Semaphore
Semaphore与锁类似，但是与锁不同的是，Synchronized是独占式的，同一时刻只有一个线程能够操作资源，而Semaphore允许指定的多个线程同时操作同个资源。它通过获取许可，释放许可来控制多个线程操作资源。
需求：假如现在网吧有5台电脑，但是现在有8个人进入网吧，同一时间只能有5个人上机，而其中三个人主要等到其他人空出电脑的时候才能上机。
这时Semaphore就派上用场了。
1package com.bingo.thread.juc;
2
3import java.util.concurrent.Semaphore;
4
5public class SemaphoreDemo {
6 public static void main(String[] args) {
7 int N = 8; //学生数
8 Semaphore semaphore = new Semaphore(5); //电脑数目
9 for(int i=0;i<N;i++)
10 new Worker(i,semaphore).start();
11 }
12
13 static class Worker extends Thread{
14 private int num;
15 private Semaphore semaphore;
16 public Worker(int num,Semaphore semaphore){
17 this.num = num;
18 this.semaphore = semaphore;
19 }
20
21 @Override
22 public void run() {
23 try {
24 semaphore.acquire();
25 System.out.println("同学"+this.num+"占用一台电脑...");
26 Thread.sleep(2000);
27 System.out.println("--同学"+this.num+"离开电脑");
28 semaphore.release();
29 } catch (InterruptedException e) {
30 e.printStackTrace();
31 }
32 }
33 }
34}
复制代码运行结果
1同学0占用一台电脑...
2同学1占用一台电脑...
3同学2占用一台电脑...
4同学3占用一台电脑...
5同学4占用一台电脑...
6--同学0离开电脑
7--同学1离开电脑
8--同学4离开电脑
9--同学3离开电脑
10同学7占用一台电脑...
11--同学2离开电脑
12同学6占用一台电脑...
13同学5占用一台电脑...
14--同学7离开电脑
15--同学5离开电脑
16--同学6离开电脑
17
18Process finished with exit code 0
复制代码多线程是java面试中非常重要一环，算是重点和难点吧，特别是需要结合JVM一起学习，所以今后笔者还会继续推出相关博客文章，也希望读者耐心等待。