CountDownLatch/CyclicBarrier/Sem

这三个类都是基于AQS实现的类，也是面试中常考的类，今天我们来学习一下这三个类的用法。

1. CountDownLatch：
   Count：数数
   Down：向下
   Latch：门闩
   顾名思义，这个类就是用来“倒计时”的，可以用来让一个线程或多个线程等待多个线程。

下面看例子：
这个例子模拟的是同学下晚自习后，班长关门的事件。正常情况是等所有同学都走完之后，然后班长锁门，离开教室。这里新建五个线程模拟同学，主线程代表班长。

public class Test {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName() + "\t同学离开教室");
            },String.valueOf(i)).start();
        }
        System.out.println(Thread.currentThread().getName() + "班长离开教室，锁门");
    }
}

1   同学离开教室
2   同学离开教室
3   同学离开教室
4   同学离开教室
main班长离开教室，锁门
5   同学离开教室

可以看到还剩一位同学没走，班长就把门锁上了，这肯定是不行的，我们来用CountDownLatch来解决这个问题。

import java.util.concurrent.CountDownLatch;

public class Test {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(5);//设置初始门闩值，模拟还有五个同学在教室
        for (int i = 1; i <= 5; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName() + "\t同学离开教室");
                countDownLatch.countDown();//每有一个同学离开教室，门闩的值就减1
            },String.valueOf(i)).start();
        }
        countDownLatch.await();//门闩的值减到0之前，main线程阻塞
        System.out.println(Thread.currentThread().getName() + "班长离开教室，锁门");
    }
}

1   同学离开教室
2   同学离开教室
3   同学离开教室
4   同学离开教室
5   同学离开教室
main班长离开教室，锁门

再无论怎么运行，main线程一定会等五个线程都运行之后才会输出。

2. CyclicBarrier
   用来控制多个线程互相等待，只有所有线程全部到达后，这些线程才会继续执行。
   CyclicBarrier有两个构造方法：

   public CyclicBarrier(int parties){
   }
   

   public CyclicBarrier(int parties,Runnable barrierAction){
   }
   

   当所有的线程都到达时，会触发barrierAction

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class Test {
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7,new Thread(()-> {
            System.out.println("召唤神龙");
        }));//等待七个线程到位之后，执行"System.out.println("召唤神龙");" 任务。

        for (int i = 1; i <= 7; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName() + "颗龙珠已经收集");
                try {
                    cyclicBarrier.await();//设置屏障，等待所有线程到位
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            },String.valueOf(i)).start();
        }
    }
}

3. semaphore
   中文名：信号量，用于控制多个线程对互斥资源的访问控制。

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

public class Test {
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(3); // 模拟总共有三个车位

        /*
           用六个线程来模拟有六辆车要抢占三个车位
         */
        for (int i = 1; i <= 6; i++) {
            new Thread(() -> {
                try {
                    semaphore.acquire(); //抢占资源
                    System.out.println(Thread.currentThread().getName() + "\t抢到车位");
                    TimeUnit.SECONDS.sleep(3);
                    System.out.println(Thread.currentThread().getName() + "\t等待三秒后离开车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    semaphore.release();//释放资源
                }
            },String.valueOf(i)).start();
        }
    }
}

1   抢到车位
2   抢到车位
3   抢到车位
2   等待三秒后离开车位
3   等待三秒后离开车位
1   等待三秒后离开车位
4   抢到车位
6   抢到车位
5   抢到车位
4   等待三秒后离开车位
6   等待三秒后离开车位
5   等待三秒后离开车位