JUC---02JUC辅助类

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

　　1.执行原理：

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

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

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

　　2.核心方法

　　　　

 　　3.代码实现　

package com.jenne.mydemo;

import java.util.concurrent.CountDownLatch;

public class TestCountDownLatch {
    public static void main(String[] args) throws InterruptedException {
        
        //构造一个CountDownLatch，给定计数初始化为6
        CountDownLatch cd = new CountDownLatch(6);

        for (int i = 1; i <= 6; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "------>线程被灭");
                cd.countDown();//计数器--
            }).start();
        }

        cd.await();//在这里阻塞线程，当计数器变为0时才放行
        System.out.println(Thread.currentThread().getName() + "------>我是最终执行的");

    }

}

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

　　1.执行原理

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

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

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

　　2.核心方法

　　　　

　　3.代码实现

package com.jenne.mydemo;

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

public class TestCyclicBarrier {
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(
                　　　　7,          //一组线程（7个线程组成）
                new Runnable() {   //一组线程全到达后才执行的线程
                    @Override
                    public void run() {
                        System.out.println("集齐7颗龙珠召唤神龙");
                    }
                });
        for (int i = 1; i <= 7; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println(Thread.currentThread().getName() + "\t 星龙珠被收集");
                        
                        cyclicBarrier.await();//某个线程到达屏障，阻塞
                        
                    } catch (InterruptedException | BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                }
            }, String.valueOf(i)).start();
        }
    }
}

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

　　1.执行原理

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

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

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

　　2.核心代码

　　　　

 　　3.代码实现

package com.jenne.mydemo;

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

public class TestSemaphore {
    public static void main(String[] args) {

        //创建一个Semaphore实例并初始化3个不公平同步锁
        Semaphore sp = new Semaphore(3);

        //开启六个线程
        for (int i = 1; i <= 6; i++) {
            new Thread(() -> {
                try {
                    sp.acquire(); //获取一个信号量（信号量--）
                    System.out.println(Thread.currentThread().getName() + "\t号车驶入停车位");
                    TimeUnit.SECONDS.sleep(3);//睡3秒
                    System.out.println(Thread.currentThread().getName() + "\t号车驶出停车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    sp.release();//释放一个信号量（信号量++）
                }
            }, String.valueOf(i)).start();
        }

    }
}