JUC-JUC强大的辅助类讲解（Semaphore、CyclicBarrier、CountDownLatch）

一、CountDownLatch 减少计数

1、原理

* CountDownLatch主要有两个方法，当一个或多个线程调用await方法时，这些线程会阻塞。

* 其它线程调用countDown方法会将计数器减1(调用countDown方法的线程不会阻塞)，

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

2、代码

package com.atguigu.thread;


import java.util.concurrent.CountDownLatch;




/**
 * 
 * @Description:
 *  *让一些线程阻塞直到另一些线程完成一系列操作后才被唤醒。
 * 
 * CountDownLatch主要有两个方法，当一个或多个线程调用await方法时，这些线程会阻塞。
 * 其它线程调用countDown方法会将计数器减1(调用countDown方法的线程不会阻塞)，
 * 当计数器的值变为0时，因await方法阻塞的线程会被唤醒，继续执行。
 * 
 * 解释：6个同学陆续离开教室后值班同学才可以关门。
 * 
 * main主线程必须要等前面6个线程完成全部工作后，自己才能开干 
 * @author xialei
 */
public class CountDownLatchDemo
{
   public static void main(String[] args) throws InterruptedException
   {
         CountDownLatch countDownLatch = new CountDownLatch(6);
       
       for (int i = 1; i <=6; i++) //6个上自习的同学，各自离开教室的时间不一致
       {
          new Thread(() -> {
              System.out.println(Thread.currentThread().getName()+"\t 号同学离开教室");
              countDownLatch.countDown();
          }, String.valueOf(i)).start();
       }
       countDownLatch.await();
       System.out.println(Thread.currentThread().getName()+"\t****** 班长关门走人，main线程是班长");
          
   }


}

二、CyclicBarrier （循环栅栏）

1、原理

* CyclicBarrier

* 的字面意思是可循环（Cyclic）使用的屏障（Barrier）。它要做的事情是，

* 让一组线程到达一个屏障（也可以叫同步点）时被阻塞，

* 直到最后一个线程到达屏障时，屏障才会开门，所有

* 被屏障拦截的线程才会继续干活。

* 线程进入屏障通过CyclicBarrier的await()方法。

2、代码

package com.atguigu.thread;


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


/**
 * 
 * @Description: TODO(这里用一句话描述这个类的作用)  
 * @author xialei
 *
 * CyclicBarrier
 * 的字面意思是可循环（Cyclic）使用的屏障（Barrier）。它要做的事情是，
 * 让一组线程到达一个屏障（也可以叫同步点）时被阻塞，
 * 直到最后一个线程到达屏障时，屏障才会开门，所有
 * 被屏障拦截的线程才会继续干活。
 * 线程进入屏障通过CyclicBarrier的await()方法。
 * 
 * 集齐7颗龙珠就可以召唤神龙
 */
public class CyclicBarrierDemo
{
  private static final int NUMBER = 7;
  
  public static void main(String[] args)
  {
     //CyclicBarrier(int parties, Runnable barrierAction) 
     
     CyclicBarrier cyclicBarrier = new CyclicBarrier(NUMBER, ()->{System.out.println("*****集齐7颗龙珠就可以召唤神龙");}) ;
     
     for (int i = 1; i <= 7; i++) {
       new Thread(() -> {
          try {
            System.out.println(Thread.currentThread().getName()+"\t 星龙珠被收集 ");
            cyclicBarrier.await();
          } catch (InterruptedException | BrokenBarrierException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
          }
       
       }, String.valueOf(i)).start();
     }
     


  }
}

三、Semaphore

1、原理

在信号量上我们定义两种操作：

* acquire（获取） 当一个线程调用acquire操作时，它要么通过成功获取信号量（信号量减1），

*       要么一直等下去，直到有线程释放信号量，或超时。

* release（释放）实际上会将信号量的值加1，然后唤醒等待的线程。

*

* 信号量主要用于两个目的，一个是用于多个共享资源的互斥使用，另一个用于并发线程数的控制。

2、代码

package com.atguigu.thread;

import java.util.Random;

import java.util.concurrent.Semaphore;

import java.util.concurrent.TimeUnit;

/**

*

* @Description: TODO(这里用一句话描述这个类的作用)

* @author xialei

*

* 在信号量上我们定义两种操作：

* acquire（获取） 当一个线程调用acquire操作时，它要么通过成功获取信号量（信号量减1），

*             要么一直等下去，直到有线程释放信号量，或超时。

* release（释放）实际上会将信号量的值加1，然后唤醒等待的线程。

*

* 信号量主要用于两个目的，一个是用于多个共享资源的互斥使用，另一个用于并发线程数的控制。

*/

public class SemaphoreDemo

{

public static void main(String[] args)

{

Semaphore semaphore = new Semaphore(3);//模拟3个停车位

for (int i = 1; i <=6; i++) //模拟6部汽车

{

new Thread(() -> {

try

{

semaphore.acquire();

System.out.println(Thread.currentThread().getName()+"\t 抢到了车位");

TimeUnit.SECONDS.sleep(new Random().nextInt(5));

System.out.println(Thread.currentThread().getName()+"\t------- 离开");

} catch (InterruptedException e) {

e.printStackTrace();

}finally {

semaphore.release();

}

}, String.valueOf(i)).start();

}

}

}