JUC（四）——强大的辅助类讲解

最新推荐文章于 2022-08-26 15:45:27 发布

原创最新推荐文章于 2022-08-26 15:45:27 发布 · 389 阅读

0 ·

CC 4.0 BY-SA版权

Java高级专栏收录该内容

9 篇文章

订阅专栏

本文深入探讨了Java并发包中三种核心类：CountDownLatch、CyclicBarrier和Semaphore的原理与应用。CountDownLatch用于使线程在其他线程完成操作前保持阻塞；CyclicBarrier实现线程间的同步屏障；Semaphore则用于控制并发线程数量，适用于资源互斥使用场景。通过具体示例，展示了它们在实际编程中的灵活运用。

JUC（一）——Locks
JUC（二）——深入理解锁机制
 JUC（三）——线程安全类
 JUC（四）——强大的辅助类讲解
 JUC（五）——Callable
JUC（六）——阻塞队列
 JUC（七）——线程池简单使用
 JUC（八）——线程池深入讲解

本篇文章主要讲解concurrent中的三个类

1、CountDownLatch
2、CyclicBarrier
3、Semaphore

在这里插入图片描述

1、CountDownLatch

让一些线程阻塞直到另一些线程完成一系列操作后才被唤醒。
举例： 放学后班长负责锁门，班长必须要等到班里的学生都走了以后才能锁门
假设班长是main线程，教室里面有6个学生，班长要等学生走完之后锁门

  public class CountDownLatchDemo {
      public static void main(String[] args) throws InterruptedException {
          CountDownLatch countDownLatch = new CountDownLatch(6);//要等待的数量
  
          for (int i = 1; i <= 6; i++) {
              final int tempI = i;
              new Thread(() -> {
                  System.out.println("同学"+tempI+"离开");
                  //走掉一个学生
                  countDownLatch.countDown();
              }, String.valueOf(i)).start();
          }
          //班长在这里等待
          countDownLatch.await();
          System.out.println("关门");
      }
  }

2、CyclicBarrier

字面意思是可循环（Cyclic）使用的屏障（Barrier）。它要做的事情是，让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续干活。线程进入屏障通过CyclicBarrier的await()方法。
举例： 集齐七颗龙珠可以召唤神龙，在不足七颗时只能等待

  public class CyclicBarrierDemo {
      public static void main(String[] args) {
      	//设定屏障（需要达到多少个线程），以及达到屏障后要做的事情
          CyclicBarrier cyclicBarrier = new CyclicBarrier(7, ()->{System.out.println("*****召唤神龙*****");});
          for (int i = 1; i <= 7; i++) {
              final int tempI = i;
              new Thread(() -> {
                  try {
                      System.out.println("收集第"+tempI+"龙珠");
                      //龙珠数量加一，进入屏障的线程加一
                      cyclicBarrier.await();
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  } catch (BrokenBarrierException e) {
                      e.printStackTrace();
                  }
              }, String.valueOf(i)).start();
          }
  
      }
  }

3、Semaphore

在信号量上我们定义两种操作：
- acquire（获取）当一个线程调用acquire操作时，它要么通过成功获取信号量（信号量减1），要么一直等下去，直到有线程释放信号量，或超时。
- release（释放）实际上会将信号量的值加1，然后唤醒等待的线程。
信号量主要用于两个目的，一个是用于多个共享资源的互斥使用，另一个用于并发线程数的控制。
实例： 停车场有3个车位，陆陆续续一共来了6辆车

 public class SemaphoreDemo {
     public static void main(String[] args) {
     	//创建时规定容量
         Semaphore semaphore = new Semaphore(3);
 
         for (int i = 1; i <= 6; i++) {
             final int tempI = i;
             new Thread(() -> {
                 try {
                 	//获取线程
                     semaphore.acquire();
                     System.out.println(tempI+"来了");
                     TimeUnit.SECONDS.sleep(2);
                     System.out.println(tempI+"走了");
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }finally {
                 	//释放线程
                     semaphore.release();
                 }
             }, String.valueOf(i)).start();
         }
     }
 }