文章目录
- 一、辅助类是什么？
- 二、使用步骤
- 1.CountDownLatch
- 2.CyclicBarrier
- 3.Semaphere
- 三、总结
一、辅助类是什么？
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，然后唤醒等待的线程！
作用： 多个共享资源互斥的使用！并发限流，控制最大的线程数！
