JUC并发编程学习笔记（七）常用的辅助类

常用的辅助类

CountDownLatch

这是一个JUC计数器辅助类，计数器有加有减，这是减。

使用方法

1. package org.example.demo;
3. import java.util.concurrent.CountDownLatch;
5. //线程计数器
6. public class CountDownLatchDemo {
7.     public static void main(String[] args) {
8.         CountDownLatch countDownLatch = new CountDownLatch(6);//总数为6，必须要执行任务时用
9.         for (int i = 0; i < 6; i++) {
10.             new Thread(()->{
11.                 System.out.println(Thread.currentThread().getName()+" go out");
12.                 countDownLatch.countDown();//总数减1
13.             },String.valueOf(i)).start();
14.         }
15.         try {
16.             countDownLatch.await();//等待总数变为0才会往下执行，相当于阻塞当前线程
17.         } catch (InterruptedException e) {
18.             throw new RuntimeException(e);
19.         }
20.         System.out.println("关门");
21.     }
22. }

复制代码

使用前
可能会在所有人没出去之前关门

使用后
不在乎谁先出去，但是一定要总数等于0后才会关门

原理
countDownLatch.countDown();//总数减1
countDownLatch.await();//等待总数变为0才会往下执行，相当于阻塞当前线程
每次有线程调用countDown() 数量减一，假设计数器变为0，await()就会被唤醒，继续执行！
CyclicBarrier

有减法就有加法

使用方法略有不同，一是添加了达到数量后可以执行一个方法，二十await方法放在了线程的内部

1. package org.example.demo;
3. import java.util.concurrent.BrokenBarrierException;
4. import java.util.concurrent.CyclicBarrier;
6. public class CyclicBarrierDemo {
7.     public static void main(String[] args) {
8.         CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->{
9.             System.out.println("召唤神龙成功");//在达到数量后运行一个Runnable接口方法
10.         });
12.         for (int i = 1; i <= 7; i++) {
13.             //lambda表达式本质上还是new了一个类，所以无法直接拿到for循环中的变量i，需要通过一个临时变量final来作为一个中间变量来获取到i
14.             final int temp = i;
15.             new Thread(()->{
16.                 System.out.println(Thread.currentThread().getName()+":获取到了"+temp+"颗龙珠");
18.                 try {
19.                     cyclicBarrier.await();//每次等待完成后往下执行，如果达不到数量会死在这
20.                 } catch (InterruptedException e) {
21.                     throw new RuntimeException(e);
22.                 } catch (BrokenBarrierException e) {
23.                     throw new RuntimeException(e);
24.                 }
25.             },String.valueOf(i)).start();
26.         }
30.     }
31. }

复制代码

Semaphore

Semaphore：信号量

抢车位：6辆车3个车位，123占据了那么456就需要等待，当占据的车走后，那么等待的车就要进入该车位。
用于限流等操作

1. package org.example.demo;
3. import java.sql.Time;
4. import java.util.concurrent.Semaphore;
5. import java.util.concurrent.TimeUnit;
7. public class SemaphoreDemo {
8.     public static void main(String[] args) {
9. //        线程数量：限流！让没有得到的等待释放
10.         Semaphore sim = new Semaphore(3);
11.         for (int i = 0; i < 6; i++) {
12.             new Thread(()->{
13.                 //acquire 得到
14.                 //release 释放
15.                 try {
16.                     sim.acquire();
17.                     System.out.println(Thread.currentThread().getName()+":抢到车位");
18.                     TimeUnit.SECONDS.sleep(2);
19.                     System.out.println(Thread.currentThread().getName()+":离开车位");
21.                 } catch (InterruptedException e) {
22.                     throw new RuntimeException(e);
23.                 }finally {//所有需要关闭、释放的操作都放在finally中
24.                     sim.release();
25.                 }
28.             }).start();
29.         }
30.     }
31. }

复制代码

sim.acquire();//得到
sim.release();//释放
作用：多个共享资源互斥的使用！并发限流，控制最大线程数！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！