CountDownLatch: 减少计数

  • CountDownLatch 类可以设置一个计数器，然后通过 countDown 方法来进行 减 1 的操作，使用 await 方法等待计数器不大于 0，然后继续执行 await 方法 之后的语句
  • CountDownLatch 主要有两个方法，当一个或多个线程调用 await 方法时，这 些线程会阻塞
  • 其它线程调用 countDown 方法会将计数器减 1(调用 countDown 方法的线程 不会阻塞)

  • 当计数器的值变为 0 时，因 await 方法阻塞的线程会被唤醒，继续执行

    1. public class CountDownLatchDemo {
    3.   public static void main(String[] args) throws InterruptedException {
    4.       CountDownLatch countDownLatch = new CountDownLatch(6);
    6.       for (int i = 0; i < 6; i++) {
    7.           new Thread(() -> {
    8.               countDownLatch.countDown();
    9.           }, i + "").start();
    10.           System.err.println(i + "走了");
    11.       }
    13.       countDownLatch.await();
    14.       System.err.println("班长锁门了");
    15.   }
    16. }

    CyclicBarrier: 循环栅栏

  • CyclicBarrier 看英文单词可以看出大概就是循环阻塞的意思，在使用中 CyclicBarrier 的构造方法第一个参数是目标障碍数，每次执行 CyclicBarrier 一 次障碍数会加一，如果达到了目标障碍数，才会执行 cyclicBarrier.await()之后 的语句。可以将 CyclicBarrier 理解为加 1 操作

    1. public class CyclicBarrierDemo {
    3.   private static final int NUMBER = 7;
    5.   public static void main(String[] args) {
    6.       CyclicBarrier barrier = new CyclicBarrier(NUMBER, () -> {
    7.           System.err.println("集齐七颗龙珠了，召唤神龙");
    8.       });
    10.       for (int i = 0; i < 7; i++) {
    11.           new Thread(() -> {
    12.               System.err.println(Thread.currentThread().getName() + " 星龙珠收集到了");
    13.               try {
    14.                   barrier.await();
    15.               } catch (InterruptedException e) {
    16.                   e.printStackTrace();
    17.               } catch (BrokenBarrierException e) {
    18.                   e.printStackTrace();
    19.               }
    20.           }, String.valueOf(i)).start();
    21.       }
    22.   }
    23. }

    Semaphore: 信号灯

  • Semaphore 的构造方法中传入的第一个参数是最大信号量（可以看成最大线 程池），每个信号量初始化为一个最多只能分发一个许可证。使用 acquire 方 法获得许可证，release 方法释放许可

    1. public class SemaphoreDemo {
    3.   public static void main(String[] args) {
    4.       Semaphore semaphore = new Semaphore(3);
    6.       for (int i = 0; i < 6; i++) {
    7.           new Thread(() -> {
    8.               try {
    9.                   semaphore.acquire();
    10.                   System.err.println(Thread.currentThread().getName() + " 抢到了车位");
    12.                   TimeUnit.SECONDS.sleep(3);
    13.                   System.err.println(Thread.currentThread().getName() + " ---------离开了车位");
    15.                   semaphore.release();
    16.               } catch (InterruptedException e) {
    17.                   e.printStackTrace();
    18.               }
    19.           }, i + " ").start();
    20.       }
    22.   }
    23. }