JUC---02JUC辅助类

一、java.util.concurrent.CountDownLatch------减少计数

　　1.执行原理：

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

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

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

　　2.核心方法

　　　　

　　3.代码实现　

 1 package com.jenne.mydemo;
 2
 3 import java.util.concurrent.CountDownLatch;
 4
 5 public class TestCountDownLatch {
 6     public static void main(String[] args) throws InterruptedException {
 7
 8         //构造一个CountDownLatch，给定计数初始化为6
 9         CountDownLatch cd = new CountDownLatch(6);
10
11         for (int i = 1; i <= 6; i++) {
12             new Thread(() -> {
13                 System.out.println(Thread.currentThread().getName() + "------>线程被灭");
14                 cd.countDown();//计数器--
15             }).start();
16         }
17
18         cd.await();//在这里阻塞线程，当计数器变为0时才放行
19         System.out.println(Thread.currentThread().getName() + "------>我是最终执行的");
20
21     }
22
23 }

二、java.util.concurrent.CyclicBarrier------循环栅栏

　　1.执行原理

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

　　　　②、直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续干活。

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

　　2.核心方法

　　　　

　　3.代码实现

 1 package com.jenne.mydemo;
 2
 3 import java.util.concurrent.BrokenBarrierException;
 4 import java.util.concurrent.CyclicBarrier;
 5
 6 public class TestCyclicBarrier {
 7     public static void main(String[] args) {
 8         CyclicBarrier cyclicBarrier = new CyclicBarrier(
 9                 　　　　7,          //一组线程（7个线程组成）
10                 new Runnable() {   //一组线程全到达后才执行的线程
11                     @Override
12                     public void run() {
13                         System.out.println("集齐7颗龙珠召唤神龙");
14                     }
15                 });
16         for (int i = 1; i <= 7; i++) {
17             new Thread(new Runnable() {
18                 @Override
19                 public void run() {
20                     try {
21                         System.out.println(Thread.currentThread().getName() + "\t 星龙珠被收集");
22
23                         cyclicBarrier.await();//某个线程到达屏障，阻塞
24
25                     } catch (InterruptedException | BrokenBarrierException e) {
26                         e.printStackTrace();
27                     }
28                 }
29             }, String.valueOf(i)).start();
30         }
31     }
32 }

三、java.util.concurrent.Semaphore------信号灯

　　1.执行原理

　　　　acquire（获取）:当一个线程调用acquire操作时，它要么通过成功获取信号量（信号量减1），要么一直等下去，直到有线程释放信号量，或超时。

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

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

　　2.核心代码

　　　　

　　3.代码实现

 1 package com.jenne.mydemo;
 2
 3 import java.util.concurrent.Semaphore;
 4 import java.util.concurrent.TimeUnit;
 5
 6 public class TestSemaphore {
 7     public static void main(String[] args) {
 8
 9         //创建一个Semaphore实例并初始化3个不公平同步锁
10         Semaphore sp = new Semaphore(3);
11
12         //开启六个线程
13         for (int i = 1; i <= 6; i++) {
14             new Thread(() -> {
15                 try {
16                     sp.acquire(); //获取一个信号量（信号量--）
17                     System.out.println(Thread.currentThread().getName() + "\t号车驶入停车位");
18                     TimeUnit.SECONDS.sleep(3);//睡3秒
19                     System.out.println(Thread.currentThread().getName() + "\t号车驶出停车位");
20                 } catch (InterruptedException e) {
21                     e.printStackTrace();
22                 } finally {
23                     sp.release();//释放一个信号量（信号量++）
24                 }
25             }, String.valueOf(i)).start();
26         }
27
28     }
29 }