JUC类（ReentrantLock、Semaphore、CountDownLatch、CyclicBarrier）

最新推荐文章于 2024-05-17 09:00:00 发布

Youcan.

最新推荐文章于 2024-05-17 09:00:00 发布

阅读量745

点赞数 10

分类专栏： JavaEE Java 文章标签： java java-ee intellij-idea

本文链接：https://blog.csdn.net/m0_48273471/article/details/124243495

版权

Java 同时被 2 个专栏收录

76 篇文章 4 订阅

订阅专栏

JavaEE

41 篇文章 2 订阅

订阅专栏

1. ReentrantLock：可重⼊锁

2. Semaphore：信号量

3. CountDownLatch：计数器

4. CyclicBarrier：循环屏障

java.util.concurrent 下的类就叫 JUC 类，JUC 下典型的类有：

        ● ReentrantLock

        ● Semaphore

        ● CountDownLatch

        ● CyclicBarrier

1. ReentrantLock：可重⼊锁

public class ThreadDemo22 {
    public static void main(String[] args) {
        synchronized (ThreadDemo22.class) {
            System.out.println("线程执行进入了方法");
            synchronized (ThreadDemo22.class) {
                System.out.println("线程执行又进入了方法");
                synchronized (ThreadDemo22.class) {
                    System.out.println("线程执行又又进入了方法");
                }
            }
        }

    }
}
输出：
线程执行进入了方法
线程执行又进入了方法
线程执行又又进入了方法

2. Semaphore：信号量

Semaphore 信号量可以实现限流。

acquire：获取令牌

release：发布令牌

public class SemaphoreDemo1 {
    public static void main(String[] args) {
        //创建线程池
        ExecutorService service = Executors.newFixedThreadPool(5);
        //创建信号量
        Semaphore semaphore = new Semaphore(2);
        //统一任务的定义
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                Thread currThread = Thread.currentThread(); // 得到执行此任务的线程
                System.out.println("进入线程：" + currThread.getName());
                try {
                    // 如果没有可用令牌的话，那么线程会阻塞在当前位置
                    semaphore.acquire();
                    System.out.println(currThread.getName() + "：得到了令牌 | Time：" +  LocalDateTime.now());
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    System.out.println(currThread.getName() + "：释放令牌 | Time：" + LocalDateTime.now());
                    // 释放令牌
                    semaphore.release();
                }
            }
        };

        // 定义新线程执行任务
        service.submit(runnable);
        // 定义新线程执行任务
        service.submit(runnable);
        // 定义新线程执行任务
        service.submit(runnable);
        // 定义新线程执行任务
        service.submit(runnable);
        // 定义新线程执行任务
        service.submit(runnable);
    }

}
输出：
进入线程：pool-1-thread-2
进入线程：pool-1-thread-4
进入线程：pool-1-thread-5
进入线程：pool-1-thread-1
进入线程：pool-1-thread-3
pool-1-thread-4：得到了令牌 | Time：2022-04-18T11:19:28.880
pool-1-thread-2：得到了令牌 | Time：2022-04-18T11:19:28.880
pool-1-thread-4：释放令牌 | Time：2022-04-18T11:19:30.893
pool-1-thread-2：释放令牌 | Time：2022-04-18T11:19:30.893
pool-1-thread-5：得到了令牌 | Time：2022-04-18T11:19:30.893
pool-1-thread-1：得到了令牌 | Time：2022-04-18T11:19:30.893
pool-1-thread-1：释放令牌 | Time：2022-04-18T11:19:32.900
pool-1-thread-3：得到了令牌 | Time：2022-04-18T11:19:32.901
pool-1-thread-5：释放令牌 | Time：2022-04-18T11:19:32.901
pool-1-thread-3：释放令牌 | Time：2022-04-18T11:19:34.916

3. CountDownLatch：计数器

CountDownLatch: 计数器。判断线程池的任务是否已经全部执行完。

等待所有线程执行完，join（）；

等待所有线程池中所有执行完，再执行下一步，使用CountDownLatch。

countDown() ：计算器 - 1

await（）：阻塞等待，所有的任务全部执行完（等待CountDownLatch = 0之后，继续执行后面的代码）。

public class CountDownLatchDemo1 {
    public static void main(String[] args) throws InterruptedException {
        //创建计算器
        CountDownLatch countDownLatch = new CountDownLatch(5);
        //线程池
        ExecutorService service = Executors.newFixedThreadPool(5);
        //创建新线程执行任务
        for (int i = 1; i < 6; i++) {
            service.submit(() -> {
                Thread currThread = Thread.currentThread();
                System.out.println(currThread.getName()
                        + "：开始起跑" + LocalDateTime.now()) ;
                // 跑步所用时间
                int runTime = (1 + new Random().nextInt(5));
                try {
                    TimeUnit.SECONDS.sleep(runTime);
                } catch (InterruptedException exception) {
                    exception.printStackTrace();
                }
                System.out.println(currThread.getName() + "：到达终点，用时：" + runTime + " " + LocalDateTime.now());
                countDownLatch.countDown(); // 计算器 -1
            });
        }
        countDownLatch.await(); // 阻塞等待，知道线程执行完
        System.out.println("比赛结束");
    }
}
输出：
pool-1-thread-2：开始起跑2022-04-18T12:10:42.224
pool-1-thread-4：开始起跑2022-04-18T12:10:42.224
pool-1-thread-5：开始起跑2022-04-18T12:10:42.224
pool-1-thread-3：开始起跑2022-04-18T12:10:42.224
pool-1-thread-1：开始起跑2022-04-18T12:10:42.224
pool-1-thread-3：到达终点，用时：1 2022-04-18T12:10:43.232
pool-1-thread-4：到达终点，用时：2 2022-04-18T12:10:44.236
pool-1-thread-2：到达终点，用时：3 2022-04-18T12:10:45.228
pool-1-thread-5：到达终点，用时：3 2022-04-18T12:10:45.228
pool-1-thread-1：到达终点，用时：5 2022-04-18T12:10:47.241
比赛结束

4. CyclicBarrier：循环屏障

await () ：计数器 - 1 ，判断当前奇数骑是否为0，如果为0，冲破栅栏执行之后的代码；否则阻塞等待，直到栅栏被冲破。

public class CyclicBarrierDemo1 {
    public static void main(String[] args) {
        // 循环屏障
        CyclicBarrier cyclicBarrier = new CyclicBarrier(5, new Runnable() {
            @Override
            public void run() {
                System.out.println("计数器为 0 了");
            }
        });

        // 创建线程池
        ExecutorService service = Executors.newFixedThreadPool(10);

        for (int i = 0; i < 10; i++) {
            int finalI = i;
            service.submit(() -> {
                Thread currThread = Thread.currentThread();
                System.out.println("执行线程：" + currThread.getName());
                try {
                    Thread.sleep(500 * finalI);
                    cyclicBarrier.await(); // 执行阻塞等待（计数器 -1，阻塞等待，直到循环屏障的计数器为 0 的时候，再执行后面的代码）
                } catch (InterruptedException exception) {
                    exception.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
                System.out.println("线程执行完成：" + currThread.getName());
            });
        }


    }
}
输出：
执行线程：pool-1-thread-1
执行线程：pool-1-thread-5
执行线程：pool-1-thread-4
执行线程：pool-1-thread-3
执行线程：pool-1-thread-2
执行线程：pool-1-thread-6
执行线程：pool-1-thread-7
执行线程：pool-1-thread-8
执行线程：pool-1-thread-9
执行线程：pool-1-thread-10
计数器为 0 了
线程执行完成：pool-1-thread-5
线程执行完成：pool-1-thread-4
线程执行完成：pool-1-thread-3
线程执行完成：pool-1-thread-2
线程执行完成：pool-1-thread-1
计数器为 0 了
线程执行完成：pool-1-thread-10
线程执行完成：pool-1-thread-6
线程执行完成：pool-1-thread-8
线程执行完成：pool-1-thread-7
线程执行完成：pool-1-thread-9