JUC- 常用辅助类

6.1 CountDownLatch

6.1.1 基本概念

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Qp6uFu8K-1614138326808)(https://guardwhy.oss-cn-beijing.aliyuncs.com/img/javaSE/se2/33-javase.png)]

6.1.2 底层源码

6.1.3 代码示例

package cn.guardwhy.juc01;

import java.util.concurrent.CountDownLatch;

public class CountDownLatchDemo01 {
    public static void main(String[] args) throws InterruptedException {
        // 1.创建countDownLatch对象
        CountDownLatch countDownLatch = new CountDownLatch(6);
        for (int i = 0; i <=6 ; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName() + " Start");
                // 数量-1
                countDownLatch.countDown();
            }, String.valueOf(i)).start();
        }
        // 等待计数器归零，然后再往下执行。
        countDownLatch.await();
        System.out.println("End..");
    }
}

原理分析

CountDownLatch 主要有两个方法，当一个或多个线程调用 await 方法时，这些线程会阻塞其他线程调用CountDown方法会将计数器减1(调用CountDown方法的线程不会阻塞）当计数器变为0时，await 方法阻塞的线程会被唤醒，继续执行。

6.2 CyclicBarrier

6.2.1 基本概念

加法计数器

6.2.2 代码示例

package cn.guardwhy.juc01;

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

public class CyclicBarrierDemo01 {
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->{
            System.out.println("NBA王朝成立");
        });

        for (int i = 0; i <=7 ; i++) {
            int temp = i;
            new Thread(()->{
                System.out.println(Thread.currentThread().getName() + "拿到" + temp + "个总冠军");
                try {
                    // 等待操作
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

6.3 Semaphore

6.3.1 基本概念

信号量;信号灯;信号

6.3.2 代码示例

package cn.guardwhy.juc01;

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

public class SemaphoreDemo01 {
    public static void main(String[] args) {
        // 线程数量
        Semaphore semaphore = new Semaphore(3);
        // 多线程
        for (int i = 0; i <=5 ; i++) {
            new Thread(()->{
                try {
                    // acquire() 得到
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName() + "抢到车位");
                    TimeUnit.SECONDS.sleep(2);
                    System.out.println(Thread.currentThread().getName() + "离开车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    // 释放资源
                    semaphore.release();
                }
            }).start();
        }
    }
}

6.3.3 原理分析

CyclicBarrier：指定个数线程执行完毕再执行操作。

semaphore：同一时间只能有指定数量个得到线程。

在信号量上两种操作

acquire（获取）

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

release （释放）

• 实际上会将信号量的值 + 1，然后唤醒等待的线程。
• 信号量主要用于两个目的：一个是用于多个共享资源的互斥使用，另一个用于并发线程数的控制。

作用: 多个共享资源互斥的使用，并发限流，控制最大的线程数！！！