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

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();
           }
       }
   }
  

来源：CSDN

作者：# Never Give up &

链接：https://blog.csdn.net/qq_41939020/article/details/103613229