常用辅助类

CountDownLatch

package com.cz.add;

import java.util.concurrent.CountDownLatch;

/**
 * @author 卓亦苇
 * @version 1.0
 * 2023/3/5 16:07
 */
//计数器
public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        //参数为int型，为倒计时
        //需要按照顺序执行任务时使用
        CountDownLatch countDownLatch = new CountDownLatch(6);
        for (int i = 0; i < 7; i++) {
        new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"执行");
                countDownLatch.countDown();//每次逐级减1

        },String.valueOf(i)).start();
        }
        countDownLatch.await();
        System.out.println("关闭");
    }
}

原理:

• countDownLatch. countDowno;/数量-1
• countDownLatch.awaitO;//等待计数器归零，然后再向下执行
• 每次有线程调用countDown()数量-1，假设计数器变为0，countDownLatch.await()就会被唤醒，继续执行!

CyclicBarrier

package com.cz.add;

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

/**
 * @author 卓亦苇
 * @version 1.0
 * 2023/3/5 16:20
 */
public class CyclicBarrierTest {
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->{
            System.out.println("集齐龙珠");
        });
        for (int i = 1; i <=7; i++) {
            int finalI = i;
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"集齐了第"+ finalI +"颗龙珠");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                } catch (BrokenBarrierException e) {
                    throw new RuntimeException(e);
                }
            }).start();
        }

    }
}

Semaphore

package com.cz.add;

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

/**
 * @author 卓亦苇
 * @version 1.0
 * 2023/3/6 9:37
 */
public class SemaphoreTest {
    public static void main(String[] args) {
        //线程数
        Semaphore semaphore = new Semaphore(3);
        for (int i = 0; i <= 6; i++) {
            new Thread(()->{
                //acquire()得到
                //release() 释放
                try {
                    semaphore.acquire();
                    TimeUnit.SECONDS.sleep(1);
                    System.out.println(Thread.currentThread().getName()+"抢到了车位");
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }finally {
                    semaphore.release();
                    System.out.println(Thread.currentThread().getName()+"离开了车位");

                }
            },String.valueOf(i)).start();
        }
    }
}

原理︰
semaphore.acquire()
获得，假设如果已经满了，等待，等待被释放为止!
semaphore.release();释放，会将当前的信号量释放＋1，然后唤醒等待的线程!

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