JUC下典型的类

最新推荐文章于 2024-07-27 13:31:57 发布

Youcan.

最新推荐文章于 2024-07-27 13:31:57 发布

阅读量346

点赞数

分类专栏： JavaEE 文章标签： java

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

版权

JavaEE 专栏收录该内容

41 篇文章 2 订阅

订阅专栏

1. 可重入锁 ReentrantLock

2. 信号量 Semaphore

3. 计数器 CountDownLatch

4. 循环屏障 CyclicBarrier

JUC就是java.util.concurrent工具包的简称。这是一个处理线程的工具包。提供了许多在并发编程工程中常用的工具类，用于定义类似于线程的自定义子系统，包括线程池、异步IO、轻量级框架、还提供了多线程上下文的Collectiion的实现。

1. 可重入锁 ReentrantLock

2. 信号量 Semaphore

semaphore.acquire();  // 得到令牌


semaphore.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-1
进入线程：pool-1-thread-3
进入线程：pool-1-thread-4
进入线程：pool-1-thread-5
进入线程：pool-1-thread-2
pool-1-thread-3：得到了令牌 | Time：2022-08-17T15:34:31.616
pool-1-thread-1：得到了令牌 | Time：2022-08-17T15:34:31.616
pool-1-thread-1：释放令牌 | Time：2022-08-17T15:34:33.632
pool-1-thread-3：释放令牌 | Time：2022-08-17T15:34:33.632
pool-1-thread-4：得到了令牌 | Time：2022-08-17T15:34:33.632
pool-1-thread-5：得到了令牌 | Time：2022-08-17T15:34:33.632
pool-1-thread-5：释放令牌 | Time：2022-08-17T15:34:35.646
pool-1-thread-4：释放令牌 | Time：2022-08-17T15:34:35.646
pool-1-thread-2：得到了令牌 | Time：2022-08-17T15:34:35.646
pool-1-thread-2：释放令牌 | Time：2022-08-17T15:34:37.658

3. 计数器 CountDownLatch

判断线程池的任务是否已经全部执行完。

countDownLatch.countDown(); // 计算器 -1

countDownLatch.await(); // 阻塞等待，直到线程执行完

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-08-17T15:36:16.643
pool-1-thread-5：开始起跑2022-08-17T15:36:16.644
pool-1-thread-1：开始起跑2022-08-17T15:36:16.643
pool-1-thread-4：开始起跑2022-08-17T15:36:16.644
pool-1-thread-3：开始起跑2022-08-17T15:36:16.643
pool-1-thread-3：到达终点，用时：2 2022-08-17T15:36:18.649
pool-1-thread-1：到达终点，用时：3 2022-08-17T15:36:19.651
pool-1-thread-5：到达终点，用时：4 2022-08-17T15:36:20.649
pool-1-thread-4：到达终点，用时：4 2022-08-17T15:36:20.649
pool-1-thread-2：到达终点，用时：5 2022-08-17T15:36:21.657
比赛结束

4. 循环屏障 CyclicBarrier

线程分组的阻塞

 cyclicBarrier.await(); // 执行阻塞等待（计数器 -1，阻塞等待，直到循环屏障的计数器为 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-3
执行线程：pool-1-thread-5
执行线程：pool-1-thread-4
执行线程：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-3
线程执行完成：pool-1-thread-4
线程执行完成：pool-1-thread-1
线程执行完成：pool-1-thread-2
计数器为 0 了
线程执行完成：pool-1-thread-10
线程执行完成：pool-1-thread-8
线程执行完成：pool-1-thread-7
线程执行完成：pool-1-thread-6
线程执行完成：pool-1-thread-9