juc笔记之常用辅助类

一、辅助类是什么？

juc里面有三大辅助类，分别是CountDownLatch，CyclicBarrier以及Semaphere。
第一个是减法计数器，作为需要执行完固定的任务之后才能接着执行后面的程序。

第二个是一个加法计数器，作为到了某个固定的次数之后，才执行某个固定的任务。

第三个是信号量，跟操作系统里面的概念一致，申请资源，执行任务，释放资源，然后另外一个线程才能再次申请新的资源，注意这个资源是作为共享资源的，多个线程可能都要使用到，如果信号量为1，那么资源只能被一个线程所拥有。

二、使用步骤

1.CountDownLatch

减法计数器，线程每次执行完成某一个任务，让计数器进行减一操作，当减为零时，就执行await()之后的任务。

**package com.lhh.fuzhu;

import java.util.concurrent.CountDownLatch;

/**
*CountDownLatch特点:
 *  countDownLatch.countDown(); // 数量-1
*  countDownLatch.await(); // 等待计数器归零，然后再向下执行
 * 每次有线程调用 countDown() 数量-1，假设计数器变为0，countDownLatch.await() 就会被唤醒，继续
 * 执行
* @author HaiHui
* @date 2021/1/30 16:21
* @param
* @return
*/
public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(6);
        for (int i = 0; i < 6; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"执行");
                countDownLatch.countDown();
                System.out.println("还剩下计数数目:"+countDownLatch.getCount());
            }).start();
        }
        countDownLatch.await();
        System.out.println("当计数减为零之后，我这里就执行啦，嘿嘿");
    }
}

执行结果：

2.CyclicBarrier

加法计数器，每个线程执行完一次任务之后，计数器会加一，到了次数为10的时候，才会执行new CyclicBarrier里面的方法。

package com.lhh.fuzhu;

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

/**
 * CyclicBarrier的使用步骤:
 * 1.创建该对象，构造里面规定parties和创建runnable接口
 * 2.调用多个线程执行，在内部调用执行await方法,用来控制每次循环自增。
 *
 * @param
 * @author HaiHui
 * @date 2021/1/30 16:30
 * @return
 */
public class CyclicBarrierDemo {
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(10, new Runnable() {
            @Override
            public void run() {
                System.out.println("终于执行了10次,run方法终于运行啦");
            }
        });

        for (int i = 0; i < 10; i++) {
            int finalI = i;
            new Thread(() -> {
                System.out.println(finalI + "............");
                try {
                    cyclicBarrier.await();
                    //获取计数总数（多少次之后，会执行runnable接口的run方法。）
                    System.out.println(cyclicBarrier.getParties());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

执行结果：

3.Semaphere

信号量，当某个线程访问了某个公共资源之后，其Semaphere信号量就会减一，如果信号量为零，说明就已经饱和了，后面的线程想要访问该资源的话，就需要等前面占有该资源的线程释放资源（那么该资源就会增加一），后面的线程才能继续执行。

package com.lhh.fuzhu;

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

public class SemaphereDemo {
    public static void main(String[] args) throws InterruptedException {
        //就好比现在一个餐馆只有三张桌子供应吃饭
        Semaphore semaphore = new Semaphore(3);

        //但是现在有十个人要进来吃饭，那么每次只有等到先进去的三个人的离开之后，后面的人才能进去。
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                try {
                    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();
                }
            }, String.valueOf(i)).start();
        }
    }
}

执行结果:

三、总结

CountDownLatch
countDownLatch.countDown(); // 数量-1

countDownLatch.await(); // 等待计数器归零，然后再向下执行

每次有线程调用 countDown() 数量-1，假设计数器变为0，countDownLatch.await() 就会被唤醒，继续执行
CyclicBarrier
创建该对象，构造里面规定parties和创建runnable接口

调用多个线程执行，在内部调用执行await方法,用来控制每次循环自增。

Semaphere
semaphore.acquire() 获得，假设如果已经满了，等待，等待被释放为止！

semaphore.release(); 释放，会将当前的信号量释放 + 1，然后唤醒等待的线程！

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