初始JavaEE篇——多线程(8):JUC的组件

news2024/11/4 17:53:49

找往期文章包括但不限于本期文章中不懂的知识点:

个人主页:我要学编程程(ಥ_ಥ)-CSDN博客

所属专栏:JavaEE

目录

Callable接口

ReentrantLock

synchronized 与 ReentrantLock的区别 

信号量(Semaphore)

CountDownLatch

多线程下使用ArrayList、哈希表


JUC 是值 java.util.current 包,现在我们要学习这些包中的一些常用的类。

Callable接口

Callable 接口与Runnable接口一样,都是用来包装任务的,只不过Callable接口有泛型参数且其方法有返回值,我们下面就来演示Callable接口的使用。

代码演示:

public class Test {
    private static int count = 0;
    public static void main(String[] args) throws InterruptedException {
        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception { // 这里面是任务与run方法类似
                for (int i = 0; i < 10000; i++) {
                    count++;
                }
                return count;
            }
        };

        // 将任务进一步分装起来
        FutureTask<Integer> task = new FutureTask<>(callable);

        // 再将任务给到Thread
        Thread t = new Thread(task);
        t.start();
        t.join();

        System.out.println("count: "+ count);
    }
}

下面是lambda表达式的写法:

public class Test {
    private static int count = 0;
    public static void main(String[] args) throws InterruptedException {
        // 使用lambda表达式代替匿名内部类
        FutureTask<Integer> task = new FutureTask<>(()->{
            for (int i = 0; i < 10000; i++) {
                count++;
            }
            return count;
        });

        Thread t = new Thread(task);
        t.start();
        t.join();

        System.out.println("count: "+count);
    }
}

上面是我们手动使 main线程阻塞等待 t线程执行完毕,我们还可以使用 FutureTask 中的get方法,从而去被动阻塞 main线程。

public class Test {
    private static Object locker = new Object();
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        FutureTask<Integer> task = new FutureTask<>(()->{
           int sum = 0;
            for (int i = 1; i <= 1000; i++) {
                sum += i;
            }
            return sum;
        });

        Thread t = new Thread(task);
        t.start();
        // 在调用get方法时,得到的是call方法的返回值,即主线程会阻塞等待t线程执行完call方法
        System.out.println(task.get());
    }
}

总结:Callable 接口也是函数式接口,通过 call 方法来完成任务,最终的任务需要被 FutureTask进一步分装,从而给到Thread。

ReentrantLock

ReentrantLock是可重入互斥锁,和 synchronized 定位类似,都是用来实现互斥效果,保证线程安全。但是ReentrantLock 是Java标准库提供的一个类,而不是关键字。

ReentrantLock 有三种方法:

1、lock():加锁,如果获取不到锁就会一直等待,也就是死等。

2、tryLock(超时时间,时间级别):加锁,如果在超时时间之内没有获取到锁,也是一直等待,但如果超出了超时时间的话,就会放弃等待。

3、unlock():解锁。

代码演示:

1、lock—unlock方法的使用:

public class Test {
    private static int count = 0;
    public static void main(String[] args) throws InterruptedException {
        ReentrantLock reentrantLock = new ReentrantLock();
        Thread t1 = new Thread(()->{
            for (int i = 0; i < 100000; i++) {
                reentrantLock.lock();
                count++;
                reentrantLock.unlock();
            }
        });
        Thread t2 = new Thread(()->{
            for (int i = 0; i < 100000; i++) {
                reentrantLock.lock();
                count++;
                reentrantLock.unlock();
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("count: "+count);
    }
}

 2、tryLock方法的使用:

public class Test {
    public static void main(String[] args) throws InterruptedException {
        ReentrantLock reentranLock = new ReentrantLock();
        Thread t = new Thread(()->{
            try {
                reentranLock.lock();
                System.out.println("t线程开始");
                Thread.sleep(3000);
                System.out.println("t线程结束");
                reentranLock.unlock();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        t.start();
        Thread.sleep(1000); // 确保t线程先加锁成功
        // 等待1s之后,就会不等了
        boolean state = reentranLock.tryLock(1000, TimeUnit.MILLISECONDS);
        if (state) {
            System.out.println("main线程成功获取锁");
            reentranLock.unlock();
        } else {
            System.out.println("main线程获取锁失败");
        }
        System.out.println("main线程结束");
    }
}

运行结果:

tryLock还有一个重载的方法,是不带有任何参数的,其含义是:尝试去获取锁时,如果锁处于空闲状态就返回true,否则就返回false。这个是不会去等待的。 

synchronized 与 ReentrantLock的区别 

1、synchronized 是关键字,其底层的实现是JVM内部通过C++实现的,而 ReentrantLock 是标准库中的类,是用Java实现的。

2、synchronized 是通过代码块来控制加锁与解锁的,而 ReentrantLock是通过lock 与 unlock 方法来控制加锁与解锁的,且一定要记得及时去解锁。

3、ReentrantLock 除了普通的加锁、解锁操作之外,还提供了 tryLock方法。不带参数的版本,就是直接去判断这个锁的状态,如果没有线程持有的话,就会进行加锁操作,然后返回true;反之,则会直接返回false,不会进行等待。而带有参数的版本就会等待对应的超时时间去尝试获取锁,如果在超时时间之外了,就会直接返回false。

4、ReentrantLock 本身默认是非公平锁,但是其提供了 公平锁的实现方式。

5、ReentrantLock搭配的等待通知机制,是Condition类,相比wait notify来说功能更强大一些,但是使用的方法是类似的。也是需要先加锁,然后再进行使用的。await 方法是可以更精准地唤醒等待的线程。在有多个等待线程的情况下,signal 可以选择唤醒特定的线程,而Object 类的notify方法在唤醒线程时是相对随机的。

代码演示:

public class Test {
    public static void main(String[] args) throws InterruptedException {
        // 下面的锁就是公平锁,是在参数内部传入一个true即可
        ReentrantLock reentrantLock = new ReentrantLock(true);
        Condition condition = reentrantLock.newCondition();
        Thread t1 = new Thread(()->{
            System.out.println("t线程开始执行");
            reentrantLock.lock();
            try {
                System.out.println("t1线程即将被阻塞");
                condition.await(); // 阻塞线程t1
                System.out.println("t1线程被唤醒");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            reentrantLock.unlock();
            System.out.println("t线程结束执行");
        });
        t1.start();
        Thread.sleep(1000); // 确保t1线程先加锁成功

        Thread t2 = new Thread(()->{
            System.out.println("t2线程开始执行");
            reentrantLock.lock();
            condition.signal(); // 唤醒正在处于阻塞状态的线程
            reentrantLock.unlock();
            System.out.println("t2线程结束执行");
        });
        t2.start();
        System.out.println("main线程结束");
    }
}

信号量(Semaphore)

信号量主要用来协调进程与线程之间的资源分配。其底层是一个计数器,记录当前资源的可用个数。申请资源,对应的P操作,信号量会减少,释放资源,对应的V操作,信号量会增加。当信号量对应的计数器为0了,此时线程再去申请资源的话,就会线程阻塞。

在Java标准库中,Semaphore 是对应的类。

代码演示:

public class Test {
    public static void main(String[] args) throws InterruptedException {
        // 通过参数指定“可用资源”的个数
        Semaphore semaphore = new Semaphore(5);
        System.out.println("可用资源的个数:"+semaphore.availablePermits());
        // 获取资源
        for (int i = 0; i < 3; i++) {
            System.out.println("正在获取可用资源~");
            // 获取"可用资源"
            semaphore.acquire(); // 也可以传入参数来设定获取的个数,默认1
        }
        System.out.println("剩余可用资源的个数:"+semaphore.availablePermits());
        // 释放资源
        for (int i = 0; i < 3; i++) {
            System.out.println("正在释放可用资源~");
            // 释放“可用资源”
            semaphore.release(); // 也可以传入参数来设定释放的个数,默认1
        }
        System.out.println("最终可用资源的个数:"+semaphore.availablePermits());
    }
}

运行结果:

注意:当信号量的初始容量为1时,此时就相当于是一把锁。 

CountDownLatch

当一个大的任务被分成多个小任务时,如何知道所有的小任务全部执行完了呢?

1、可以使用 join 的普通等待方法。

2、可以使用计数器来记录当前的完成任务的线程数。

而针对第二种方式,Java标准库中给出了一个类:CountDownLatch。通过构造方法创建出多个任务,当与之对应的线程完成一个任务时,就可以调用 countDown方法来更新计数器的值,最终当计数器的值达到我们的预期时,便可以让主线程继续去执行其它的逻辑了。

代码实现:

public class Test {
    public static void main(String[] args) throws InterruptedException {
        int n = 3;
        CountDownLatch latch = new CountDownLatch(n); // 创建了初始值为n的计数器
        // 模拟下载的线程
        System.out.println("等待下载...");
        for (int i = 0; i < n; i++) {
            new Thread(() -> {
                System.out.println("正在下载...");
                try {
                    // 模拟下载过程
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("下载完成...");
                latch.countDown(); // 更新计数器,计数器--
            }).start();
        }
        // 等待上述任务全部执行完毕,当计数器为0时,任务执行完毕,脱离阻塞。
        // 任务没有执行完成时,主线程会处于阻塞状态
        latch.await();
        System.out.println("下载完成,正在解压...");
        System.out.println("成功解压...");
    }
}

多线程下使用ArrayList、哈希表

普通的ArrayList是没有加锁的,那么在多线程的情境下使用,就会出现线程安全问题,而解决线程安全问题,有三种方法:

1、根据需要自行加锁。

2、无脑将所有的可能会出现线程安全问题的代码全部进行加锁。

3、CopyOnWriteArrayList。

第一二种方式都是采用加锁操作,来确保线程安全。

代码演示:

public class Test {
    private static final Object locker = new Object();
    public static void main(String[] args) throws InterruptedException {
        ArrayList<Integer> arrayList = new ArrayList<>();
        Thread t1 = new Thread(()->{
            for (int i = 0; i < 100000; i++) {
                synchronized (locker) {
                    arrayList.add(i);
                }
            }
        });
        Thread t2 = new Thread(()->{
            for (int i = 0; i < 100000; i++) {
                synchronized (locker) {
                    arrayList.add(i);
                }
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(arrayList.size());
    }
}

上面这种方式就是按需加锁,只在出现线程安全问题的代码部分进行加锁操作,而不是对add这个方法进行无脑的加锁。 

第三种方式,采用了写时拷贝的方法。当线程1在进行"写"操作时,如果线程2来进行"读"操作,这时就让线程2读取原来版本的数据,这样线程1在进行"写"操作时,就不会影响到线程2的"读"操作,也就不会造成线程不安全,那么也就没必要进行加锁操作,从而导致的程序运行效率降低。

缺陷:

1、当数据量过大时,拷贝的成本也就高了很多,这样最终的效率可能还不如加锁的操作呢。

2、当多个线程进行修改操作时,就不能保证线程安全了。因为多个线程进行修改操作,就会拷贝出多份数据,最后怎么合并呢?可能会出现覆盖的问题,其次这是并发执行,因此没发确定顺序的先后,因此就导致了最终数据的不确定性。 

普通的哈希表也是有线程安全问题的。Java标准库中,给我们提供了两个类:Hashtable、ConcurrentHashMap。前者是对整个哈希表进行加锁操作,而后者是对哈希表的每个元素进行加锁操作。

不管是Java标准库中的哈希表,还是我们之前手动实现的哈希表,针对哈希冲突的问题,我们采用的都是数组+链表的方式,而不是去使用线性探测。而对于数组+链表这种方式,只有在同一个链表上面进行修改操作时,才会涉及线程安全问题,因此没必要对整个数组进行加锁。

ConcurrentHashMap相对于Hashtable有以下三个优化的地方:

1、针对数组的加锁操作,变成了对链表进行加锁操作;

2、使用原子类对size进行维护;

3、对于哈希扩容的问题,是分多次进行的,这样每一次所消耗的时间就会比较少。例如,准备扩容时,就可以标记一下,等到下一次在进行put操作时,重新将这个元素所在原链表进行新的哈希映射,当每一个链表都修改完毕时,哈希表的扩容操作也就完成了。

好啦!本期 初始JavaEE篇——多线程(8):JUC的组件 的学习之旅就到此结束啦!我们下一期再一起学习吧!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/2230883.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

Vue3+Data-V实现可视化大屏页面布局

目录 一、前言 二、环境准备 1.Vue3安装npm create vuelatest 2.Data-V配置 项目Data-v安装 main.js中注册Data-v到全局 ​编辑可使用按需引入 3.测试 三、导航栏路由跳转配置 1.子组件mainNav组件准备 2.父组件准备导航栏参数传递 3.子组件接收父组件参数 4.导航…

Solana 代币 2022 — Transfer Hook

从零到英雄的 Solana 代币 2022 — Transfer Hook Token 2022 计划引入了几项令人兴奋的扩展&#xff0c;增强了铸造和代币账户的功能。在这些功能中&#xff0c;我个人最喜欢的是Transfer Hook &#xff08;转账钩子&#xff09; 。 想象时间 让我们戴上想象的帽子&#xf…

Edge浏览器设置优化

依次点击右上角的三个点-“设置”。 在“外观”设置项中&#xff0c;关闭“显示选项卡操作菜单”、“在垂直选项卡中隐藏标题栏”、“在标题栏中显示个人资料图标”&#xff0c;选择“不显示独立搜索框”。 在“选择要在工具栏上显示的按钮”&#xff0c;开启“下载按钮”。 重…

电脑软件:推荐一款免费且实用的电脑开关机小工具

目录 一、软件简介 二、软件功能 三、软件特点 四、使用说明 五、软件下载 今天给大家推荐一款免费且实用的电脑开关机小工具KShutdown&#xff0c;有需要的朋友可以下载试一下&#xff01; 一、软件简介 KShutdown是一款精巧且实用的定时自动关机小工具&#xff0c;对于…

Python Matplotlib 子图绘制

Python 中的子图绘制 在数据可视化中&#xff0c;展示多个图表在同一个画布上是常见的需求&#xff0c;这样可以更直观地比较不同数据集之间的关系。Python 中的 Matplotlib 库为我们提供了强大的功能来实现这一点。在本篇文章中&#xff0c;我们将详细介绍如何使用 Matplotli…

透明加密技术是什么?透明加密技术的原理与应用实践(内含代表性软件分享)

触目惊心&#xff01;10大典型间谍案例回顾 张某离职前搜集大量文件资料&#xff0c;甚至拆开电脑主机拷贝文件 私自存有5200份文件资料 其中标注绝密级的59份 机密级848份 秘密级541份 在当今这个信息化高速发展的时代&#xff0c;透明加密技术已不容忽视。那么&#xff…

rhce:web服务器

web服务器简介 服务器端&#xff1a;此处使用 nginx 提供 web 服务&#xff0c; RPM 包获取&#xff1a; http://nginx.org/packages/ /etc/nginx/ ├── conf.d #子配置文件目录 ├── default.d ├── fastcgi.conf ├── fastcgi.conf.default ├── fastcgi_params #用…

后端:Spring、Spring Boot-实例化Bean依赖注入(DI)

文章目录 1. 实例化Bean2. 使用FactoryBean3. 依赖注入(DI)3.1 AutoWired 属性注入(查找顺序&#xff1a;先类型&#xff0c;后名字)3.2 AutoWired 在构造函数&参数上的使用3.3 Inject和Resource 进行依赖注入3.4 Value 进行注入 1. 实例化Bean 默认使用无参构造函数&…

Android——横屏竖屏

系统配置变更的处理机制 为了避免横竖屏切换时重新加载界面的情况&#xff0c;Android设计了一中配置变更机制&#xff0c;在指定的环境配置发生变更之时&#xff0c;无需重启活动页面&#xff0c;只需执行特定的变更行为。该机制的视线过程分为两步&#xff1a; 修改 Androi…

ubuntu openmpi安装(超简单)

openmpi安装 apt update apt install openmpi-bin openmpi-common libopenmpi-dev安装到此完毕 测试一下&#xff0c;success !

基于DCT的数字水印算法

摘要 数字水印技术近年来得到了较大的发展&#xff0c;基于变换域的水印技术是目前研究的热点。数字水印是利用数字作品中普遍存在的冗余数据和随机性&#xff0c;把标识版权的水印信息嵌入到数字作品中&#xff0c;从而可以起到保护数字作品的版权或其完整性的一种技术。 一个…

【Linux指令】---获取进程的PID

获取进程的PID getpid()函数

李红《复变函数与积分变换》第五版课后习题答案PDF

《复变函数与积分变换(第五版)学习辅导与习题全解》是与《复变函数与积分变换(第五版)》(华中科技大学数学与统计学院)配套的学习辅导书&#xff0c; 全书共八章&#xff1a;复数与复变函数&#xff0c; 解析函数&#xff0c;复变函数的积分&#xff0c; 解析函数的级数表示&am…

Zypher Network:全栈式 Web3 游戏引擎,服务器抽象叙事的引领者

近期&#xff0c;《黑神话&#xff1a;悟空》的爆火不仅让 AAA 游戏重回焦点&#xff0c;也引发了玩家与开发者的热议。Web2 游戏的持续成功导致部分 Web3 玩家们的倒戈&#xff0c;对比之下 Web3 游戏存在生命周期短且商业模式难以明确的问题&#xff0c;尤其在当前加密市场环…

【Linux】利用 <信号量> 实现 <生产者-消费者模型-线程同步 >(思维导图&代码演示&思路解析)

前言 大家好吖&#xff0c;欢迎来到 YY 滴Linux系列 &#xff0c;热烈欢迎&#xff01; 本章主要内容面向接触过C的老铁 主要内容含&#xff1a; 欢迎订阅 YY滴C专栏&#xff01;更多干货持续更新&#xff01;以下是传送门&#xff01; YY的《C》专栏YY的《C11》专栏YY的《Lin…

「Mac畅玩鸿蒙与硬件20」鸿蒙UI组件篇10 - Canvas 组件自定义绘图

Canvas 组件在鸿蒙应用中用于绘制自定义图形,提供丰富的绘制功能和灵活的定制能力。通过 Canvas,可以创建矩形、圆形、路径、文本等基础图形,为鸿蒙应用增添个性化的视觉效果。本篇将介绍 Canvas 组件的基础操作,涵盖绘制矩形、圆形、路径和文本的实例。 关键词 Canvas 组件…

spark-on-k8s 介绍

spark-on-k8s 介绍 摘要 最近一段时间都在做与spark相关的项目&#xff0c;主要是与最近今年比较火的隐私计算相结合&#xff0c;主要是在机密计算领域使用spark做大数据分析、SQL等业务&#xff0c;从中也了解到了一些spark的知识&#xff0c;现在做一个简单的总结&#xff…

【运动的&足球】足球场地区域图像分割系统源码&数据集全套:改进yolo11-RFAConv

改进yolo11-ContextGuidedDown等200全套创新点大全&#xff1a;足球场地区域图像分割系统源码&#xff06;数据集全套 1.图片效果展示 项目来源 人工智能促进会 2024.10.28 注意&#xff1a;由于项目一直在更新迭代&#xff0c;上面“1.图片效果展示”和“2.视频效果展示”展…

C语言 | Leetcode C语言题解之第525题连续数组

题目&#xff1a; 题解&#xff1a; struct HashTable {int key, val;UT_hash_handle hh; };int findMaxLength(int* nums, int numsSize) {int maxLength 0;struct HashTable* hashTable NULL;struct HashTable* tmp malloc(sizeof(struct HashTable));tmp->key 0, tm…

Java JUC(四) 自定义线程池实现与原理分析

目录 一. 阻塞队列 BlockingQue 二. 拒绝策略 RejectPolicy 三. 线程池 ThreadPool 四. 模拟运行 在 Java基础&#xff08;二&#xff09; 多线程编程 中&#xff0c;我们简单介绍了线程池 ThreadPoolExecutor 的核心概念与基本使用。在本文中&#xff0c;我们将基于前面学…