JavaEE多线程(2)

在这里插入图片描述

文章目录

  • 1..多线程的安全
    • 1.1出现多线程不安全的原因
    • 1.2解决多线程不安全的⽅法
    • 1.3三种典型死锁场景
    • 1.4如何避免死锁问题
    • 2.线程等待通知机制
    • 2.1等待通知的作用
    • 2.2等待通知的方法——wait
    • 2.3唤醒wait的方法——notify

1…多线程的安全

1.1出现多线程不安全的原因

  1. 线程在系统中是随机调度，抢占式执⾏。
  2. 多个线程同时修改同⼀个变量
  3. 线程对变量的修改操作不是“原⼦”的
  4. 内存可⻅性问题
  5. 指令重排序、
    “原⼦”是什么？
    原⼦是指不可再拆分的最⼩单位，放到代码操作中就是⼀段代码对应⼀个cpu指令就是原⼦的，如果对应到多个cpu指令就不是原⼦的。

1.2解决多线程不安全的⽅法

从原因⼊⼿：

  1. 原因1由于是系统本⾝的原因⼈为⽆法⼲预。
  2. 原因2是⼀个解决多线程不安全的⽅法，但是只是在特定的场景下才可以实现。
  3. 原因3是解决多线程不安全最合适的⽅法，既然修改的这个操作不是⼀个原⼦，那我们只需要将这
    个不是“原⼦”的操作打包成⼀个原⼦的操作即可。
    引申出⼀个新的词“锁”
    我们可以通过锁来将之前不是原⼦操作打包成⼀个原⼦操作
    关于这个锁本⾝就是系统内核中的api，只不过是jvm将这个api封装了，为了让java可以更好的使⽤这
    个锁。
    关于锁主要操作的两个⽅⾯：
    1.加锁
    ⽐如对t1线程进⾏加锁，t2线程也要加锁，那么t2线程就会阻塞等待(互斥锁/竞争锁/锁冲突)
    2.解锁
    t1线程解锁之后，t2线程才可以进⾏加锁
    注意：此处的锁主要针对于锁对象，对于t1和t2线程是指的同⼀个锁对象，不是同⼀个锁对象那就没
    意义了。
    对锁的总结：
    1.两个操作⸺加锁，解锁
    2.锁的特性⸺互斥
    3.只有多个线程竞争同⼀把锁才会互斥，如果多个线程竞争不同的锁则不会产⽣互斥
    java中⽤⼀个关键字来描述锁⸺synchronized
    1.synchronized 怎么读？怎么拼写？
    synchronized
    2.synchronized()括号中写的是锁对象⸺锁对象可以是任意类实列出的对象
    注意：
    锁对象的⽤途只有⼀个，两个线程是否针对⼀个对象加锁
    如果是就会出现锁竞争/锁冲突/互斥，就会引起阻塞等待
    如果不是就不会出现锁竞争/锁冲突/互斥，就不会引起阻塞等待
    和对象具体是什么类型，和它内部有什么属性，有什么⽅法，接下来是否要操作这个对象，统统都没
    有关系
    3.synchronized下⾯跟着{}
    当进⼊到这个代码块就是对上述(锁对象)进⾏了加锁操作
    当出了代码块就是对上述(锁对象)进⾏了解锁操作
    以下代码就是两个线程针对同⼀个对象locker加锁，当t1线程加锁之后，t2想加锁只能阻塞等待，只有
    等到t1线程解锁之后，t2线程才有可能加锁成功
public static int count = 0;
//创建一个对象作为一个锁对象
public static void main(String[] args) throws InterruptedException {Object locker = new Object();Thread t1 = new Thread(()-> {for (int i = 1; i <= 5000; i++) {synchronized(locker) {count++;}}});Thread t2 = new Thread(()-> {for (int i = 1; i <=5000 ; i++) {synchronized(locker) {count++;}}});t1.start();t2.start();t1.join();t2.join();System.out.println("count = "+ count);
}

以下代码就是两个线程对不同锁对象进行加锁，就不会产生锁冲突/锁竞争/互斥。

public static int count = 0;public static void main(String[] args) throws InterruptedException {Object locker1 = new Object();Object locker2 = new Object();Thread t1 = new Thread(() -> {for (int i = 1; i <=5000 ; i++) {synchronized(locker1) {count++;}}});Thread t2 = new Thread(() -> {for (int i = 1; i <=5000 ; i++) {synchronized(locker2) {count++;}}});t1.start();t2.start();t1.join();t2.join();System.out.println("count = " + count);
}

当t1线程解锁之后，不一定是t2线程拿到锁，有可能是其他线程拿到锁。
join与锁的区别：
join是一个线程完了，再让第二个线程执行。
锁只是针对加锁的那一块代码，就像上述代码中加锁的count++就会变成串行执行，但剩余的代码还是并发执行。
注意：加锁不是针对线程，而是针对共享资源的访问操作，比如现在我对t1线程中的操作1进行了加锁，但是系统内核将t1线程调度走了，可以让其他线程调度到t1线程的位置继续执行操作1，此时t2线程还是无法加到锁.
另外加锁的方式：
1.写一个方法将加锁的关键字放在方法中：

public static int count = 0;
synchronized public void add() {count++;
}
public static void main(String[] args) throws InterruptedException {Deom14 deom14 = new Deom14();Thread t1 = new Thread(()-> {for (int i = 1; i <= 5000; i++) {deom14.add();}});Thread t2 = new Thread(()-> {for (int i = 1; i <=5000 ; i++) {deom14.add();}});t1.start();t2.start();t1.join();t2.join();System.out.println("count = "+ count);
}

对于这种方式加锁还有一种写法：

public static int count = 0;public void add() {synchronized (this){count++;}
}
public static void main(String[] args) throws InterruptedException {Deom14 deom14 = new Deom14();Thread t1 = new Thread(()-> {for (int i = 1; i <= 5000; i++) {deom14.add();}});Thread t2 = new Thread(()-> {for (int i = 1; i <=5000 ; i++) {deom14.add();}});t1.start();t2.start();t1.join();t2.join();System.out.println("count = "+ count);
}

利用this，谁调用了这个方法就用这个对象作为锁对象，
2.synchronized对static方法进行加锁，相当于对类的类对象进行加锁

public static int count = 0;
synchronized static void func() {count++;
}public static void main(String[] args) throws InterruptedException {Object locker = new Object();Thread t1 = new Thread(()-> {for (int i = 1; i <= 5000; i++) {Deom15.func();}});Thread t2 = new Thread(()-> {for (int i = 1; i <=5000 ; i++) {Deom15.func();}});t1.start();t2.start();t1.join();t2.join();System.out.println("count = "+ count);
}

对于这种写法有个致命的缺点，一旦有多个线程调用func，则这些线程都会触发锁竞争。
4. 原因4引起的线程不安全——编译器优化产生的线程不安全

public static int count;
public static void main(String[] args) {Thread t1 = new Thread(() -> {while(count == 0) {//未执行操作}System.out.println("退出t1线程");});Thread t2 = new Thread(() -> {Scanner scanner = new Scanner(System.in);System.out.println("输入一个数：");count = scanner.nextInt();});t1.start();t2.start();
}

在t1线程中while（count == 0）这个操作在指令的角度来分析就两个指令分别为load和cmp指令
load指令将内存中数据读入cpu中寄存器
cmp在cpu寄存器中进行比较
1.内存读取数据的速度远远小于寄存器读取的数据的速度就会造成load指令执行的速度远远慢于cmp指令执行。
2.在t2线程未修改count之前load指令执行的结果是一样的。
由上述两个原因，java编译器为了提高效率就会将load指令这个操作优化，所以当t2线程修改了count的值t1线程也不会感知到。
如果在t1线程的循环体中加一些I/O操作或者阻塞操作，这样java编译器就不会去优化load指令。

public static int count;
public static void main(String[] args) {Thread t1 = new Thread(() -> {while(count == 0) {try {Thread.sleep(3000);} catch (InterruptedException e) {throw new RuntimeException(e);}}System.out.println("退出t1线程");});Thread t2 = new Thread(() -> {Scanner scanner = new Scanner(System.in);System.out.println("输入一个数：");count = scanner.nextInt();});t1.start();t2.start();
}

如何解决由编译器优化引起的线程不安全？
1.上述在循环体中加I/O操作或者阻塞操作可以解决
2.用volatile关键字来修饰需要修改的变量——这个关键字只能解决编译器优化带来的内存可见性问题，不能解决原因三带来的问题。
volatile关键字
当为count加上volatile关键字就会告知编译器这个变量不能随便被优化`在这里插入代码片

public volatile static int count;
public static void main(String[] args) {Thread t1 = new Thread(() -> {while(count == 0) {}System.out.println("退出t1线程");});Thread t2 = new Thread(() -> {Scanner scanner = new Scanner(System.in);System.out.println("输入一个数：");count = scanner.nextInt();});t1.start();t2.start();
}
  1. 原因5引起的线程不安全——编译器优化策略导致
    指令重排序旨在编译器在优化的时候将你的代码重新调整执行顺序来提高效率，优化前的逻辑与优化后的逻辑是等价的，在单线程中指令重排序这个优化策略是不会造成线程不安全，但是在多线程中就会导致线程不安全。
    面对指令重排序我们采取用volatile关键字
class SinlgetonLazy1 {private static volatile SinlgetonLazy1 instance = null;public static SinlgetonLazy1 getInstance() {Object locker = new Object();if(instance == null) {synchronized(locker) {if (instance == null ) {instance = new SinlgetonLazy1();}}}return instance;}private SinlgetonLazy1() {}
}
public class Deom24 {public static void main(String[] args) throws InterruptedException {SinlgetonLazy1 s = SinlgetonLazy1.getInstance();Thread t1 = new Thread(() -> {SinlgetonLazy1 s1 = SinlgetonLazy1.getInstance();});Thread t2 = new Thread(() -> {SinlgetonLazy1 s2 = SinlgetonLazy1.getInstance();});t1.start();t2.start();}
}

1.3三种典型死锁场景

场景一：锁是不可重入锁，并且一个线程针对一个锁对象，连续被加锁两次。
采取可重入锁（synchronized）就可以对这个问题迎刃而解了
场景二：两个线程两把锁
现有t1线程t2线程和locker1锁locker2锁， locker2锁要对t1线程中内容加锁，但同时locker2锁对t2线程还未解锁，所以t1线程需要阻塞等待，而现在locker1锁也要对t2线程中的内容加锁，但是locker1对t1线程还未解锁，所以t2线程需要阻塞等待，这样就导致你等我，我等你的死锁现象`

public static void main(String[] args) {Object locker1 = new Object();Object locker2 = new Object();Thread t1 = new Thread(() -> {synchronized (locker1) {try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}synchronized (locker2) {System.out.println("t1线程获取到了两把锁");}}});Thread t2 = new Thread(() -> {synchronized (locker2) {try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}synchronized (locker1) {System.out.println("t2线程获取到了两把锁");}}});t1.start();t2.start();
}

上述代码就是场景二死锁的实现代码
通过jconsole窗口观察：
在这里插入图片描述
此时就是t1线程想要获取到locker2锁，但locker2锁被t2线程给加锁了并且没有解锁，所以此时的t1线程想要获取locker2锁只能阻塞等待。
在这里插入图片描述
此时就是t2线程想要获取到locker1锁，但locker1锁被t1线程给加锁了并且没有解锁，所以此时的t2线程想要获取locker1锁只能阻塞等待。
场景三：N个线程M把锁——哲学家就餐问题
约定每一个哲学家必须先获取编号小的筷子，后获取编号大的筷子，就可以解决哲学家就餐问题。

1.4如何避免死锁问题

出现死锁的四大必要条件，少一个都不会出现死锁。

  1. 锁具有互斥特性（基本特点，一个线程拿到锁之后，其他线程就得阻塞等待）——基本特点
  2. 锁不可抢占（不可被剥夺）——基本特点
  3. 请求和保持（一个线程拿到一把锁之后，不释放这个锁的前提下，再尝试获取其他锁）——代码结构
  4. 循环等待（多个线程获取多个锁的过程中，出现了循环等待，A线程等待B线程，B线程又等待A线程）——代码结构
    要避免死锁，由于第一和第二点是锁的基本特性所以我们无法避免，我们只能从第三点和第四点出发避免死锁。
    针对第三点：我们尽量不要出现嵌套锁。
    针对第四点：我们可以约定加锁的顺序，让所有的线程按照加锁的顺序来获取锁。
    针对上述的代码出现了死锁，我们就可以约定加锁的先后顺序来避免死锁，我们约定locker1先加锁，locker2后加锁。
public static void main(String[] args) {Object locker1 = new Object();Object locker2 = new Object();Thread t1 = new Thread(() -> {synchronized (locker1) {try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}synchronized (locker2) {System.out.println("t1线程获取到了两把锁");}}});Thread t2 = new Thread(() -> {synchronized (locker1) {try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}synchronized (locker2) {System.out.println("t2线程获取到了两把锁");}}});t1.start();t2.start();
}

2.线程等待通知机制

2.1等待通知的作用

通过条件，判断当前逻辑是否能够执行，如果不满足条件不能执行，那么就主动进行阻塞(wait)让其他线程来调度cpu的资源，等到条件满足的时候，再让其它线程（阻塞的线程）来唤醒。

2.2等待通知的方法——wait

  1. wait方法是Object类提供，所以任何对象都能调用这个方法
  2. wait方法和sleep一样会被interrupt打断并且自动清空标志位
  3. wait方法不仅仅可一个阻塞等待还可以解锁
  4. wait方法要放在synchronized内部使用
public static void main(String[] args) {Object locker = new Object();Thread t1 = new Thread(() -> {synchronized (locker) {try {locker.wait();} catch (InterruptedException e) {throw new RuntimeException(e);}}});

在这里插入图片描述

2.3唤醒wait的方法——notify

  1. notify方法要放在synchronized内部使用
  2. notify方法是Object类提供，所以任何对象都能调用这个方法wait方法是Object类提供，所以任何对象都能调用这个方法
  3. notify是随机唤醒被阻塞的线程
  4. notifyAll()方法可以唤醒所有被阻塞的线程，但这种方法不常用。`
public static void main(String[] args) {Object locker = new Object();Thread t1 = new Thread(() -> {System.out.println("t1线程等待之前");synchronized (locker) {try {locker.wait();} catch (InterruptedException e) {throw new RuntimeException(e);}}System.out.println("t1线程等待结束");});Thread t2 = new Thread(() -> {System.out.println("t2线程唤醒t1线程之前");synchronized (locker) {try {Thread.sleep(3000);locker.notify();} catch (InterruptedException e) {throw new RuntimeException(e);}}System.out.println("t2线程唤醒结束");});t1.start();t2.start();
}

此时的t1线程的状态转化为：WAITTING——RUNNABLE——BLOCKED

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

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

一名女DBA的感谢信，到底发生了什么？

一名女DBA的感谢信，到底发生了什么？

昨日我们收到这样一通来电 “早上九点刚上班便收到业务投诉电话&#xff0c;系统卡顿&#xff0c;接口失败率大增&#xff0c;怀疑数据库问题。打开运维平台发现是国产库&#xff0c;生无可恋&#xff0c;第一次生产环境遇到国产库性能问题&#xff0c;没什么排查经验&#xf…
阅读更多...
数学建模基础：线性模型

数学建模基础：线性模型

目录 前言 一、线性方程组 二、线性规划 三、线性回归 四、线性模型的应用 五、实例示范&#xff1a;医疗成本预测 步骤 1&#xff1a;导入数据 步骤 2&#xff1a;数据预处理 步骤 3&#xff1a;建立多元线性回归模型 步骤 4&#xff1a;模型验证 步骤 5&#xff1…
阅读更多...
2024 年最新 windows 操作系统部署安装 redis 数据库详细教程（更新中）

2024 年最新 windows 操作系统部署安装 redis 数据库详细教程（更新中）

Redis 数据库概述 Redis 是一个开源的&#xff0c;内存中的数据结构存储系统&#xff0c;它可以用作数据库、缓存和消息中介。Redis&#xff08;Remote Dictionary Server &#xff09;&#xff0c;即远程字典服务&#xff0c;是一个开源的使用ANSI C语言编写、支持网络、可基…
阅读更多...
遥感图像地物覆盖分类，数据集制作-分类模型对比-分类保姆级教程

遥感图像地物覆盖分类，数据集制作-分类模型对比-分类保姆级教程

遥感图像地物覆盖分类，数据集制作-分类模型对比-分类保姆级教程 在遥感影像上人工制作分类数据集采用python+gdal库制作数据集挑选分类模型(RF、KNN、SVM、逻辑回归)选择随机森林模型建模分类遥感图像预测在遥感影像上人工制作分类数据集 1.新建shp文件 地理坐标系保持和影像…
阅读更多...
紫光展锐芯片进入烧录模式

紫光展锐芯片进入烧录模式

实验平台&#xff1a;移远通信SC200L搭载SMART-EVB-G5开发板 软件进入&#xff1a; SPRD平台芯片可以通过adb进入fastboot模式&#xff0c;由fastboot flash boot等指令烧录&#xff1a; $ adb root $ adb reboot fastboot $ fastboot flash boot boot.img 由于usb传输一般都…
阅读更多...
2020年中国1km格网耕地破碎度数据集

2020年中国1km格网耕地破碎度数据集

摘要 耕地破碎度是对耕地破碎化的定量描述&#xff0c;耕地破碎化是指由于自然或人为因素&#xff0c;耕地图斑数量增加&#xff0c;斑块大小减小&#xff0c;隔离程度增加&#xff0c;呈现出分散和无序格局。破碎化不仅会影响生态系统的结构和功能&#xff0c;同时不利于提高耕…
阅读更多...
开源AGV调度系统OpenTCS中的路由器(router)详解

开源AGV调度系统OpenTCS中的路由器(router)详解

OpenTCS中的任务分派器router详解 1. 引言2. 路由器(router)2.1 代价计算函数&#xff08;Cost functions&#xff09;2.2 2.1 Routing groups2.1 默认的停车位置选择2.2 可选停车位置属性2.3 默认的充电位置选择2.4 即时运输订单分配 3. 默认任务分派器的配置项4. 参考资料与源…
阅读更多...
想要高效回复客户消息？来看看这个款微信神器

想要高效回复客户消息？来看看这个款微信神器

不管是销售还是客服来说&#xff0c;能及时回复客户的反馈和问题&#xff0c;是确保顾客满意度的关键因素。 今天&#xff0c;就给大家分享一个职场必备神器——个微管理系统&#xff0c;帮助大家提高回复效率&#xff01; 首先&#xff0c;你可以在系统上设置自动通过好友后自…
阅读更多...
Windows10安装Docker Desktop（实操步骤版）

Windows10安装Docker Desktop（实操步骤版）

1&#xff0c;下载Docker Desktop 官网下载地址&#xff1a; https://desktop.docker.com/win/stable/amd64/Docker%20Desktop%20Installer.exe 国内镜像下载地址&#xff08;本人下载这个&#xff09;&#xff1a; https://smartidedl.blob.core.chinacloudapi.cn/docker/2…
阅读更多...
基于Quartus Prime18.1的安装与FPGA的基础仿真（联合Modelsim）教程

基于Quartus Prime18.1的安装与FPGA的基础仿真（联合Modelsim）教程

Quartus是一种美国科技公司Intel&#xff08;英特尔&#xff09;公司开发的FPGA&#xff08;现场可编辑门阵列&#xff09;设计编译软件&#xff0c;用作设计、仿真、综合和布局、支持多种编程语言&#xff0c;包括VHDL、Verilog等&#xff0c;并具有丰富的功能和工具库&#x…
阅读更多...
T200HSA单路SDI/HDMI+1路3.5音频高清万能采集卡

T200HSA单路SDI/HDMI+1路3.5音频高清万能采集卡

产品简介&#xff1a; 同三维T200HSA单路高清万能采集卡&#xff0c;可以采集1路SDI/HDMI高清信号1路3.5音频信号&#xff0c;卡上有1个是HDMI接口1个是SDI接口1个3.5音频口&#xff0c;配件有&#xff1a; 1个小档板&#xff0c;PCI-E2.0 X1&#xff0c;分辨率最高可以达到10…
阅读更多...
可信计算和数字水印技术

可信计算和数字水印技术

可信计算 可信计算可信计算基础概述可信计算关键技术要素可信性认证可信计算优劣 数字水印技术数字版权保护技术 可信计算 可信计算基础概述 可信计算&#xff08;Trusted Computing&#xff0c;TC&#xff09;&#xff1a;在计算和网络通信系统中广泛使用的、基于硬件安全模块…
阅读更多...
【我是产品经理_注册安全分析报告】

【我是产品经理_注册安全分析报告】

前言 由于网站注册入口容易被黑客攻击&#xff0c;存在如下安全问题&#xff1a; 暴力破解密码&#xff0c;造成用户信息泄露短信盗刷的安全问题&#xff0c;影响业务及导致用户投诉带来经济损失&#xff0c;尤其是后付费客户&#xff0c;风险巨大&#xff0c;造成亏损无底洞 …
阅读更多...
【单片机】DS2431芯片，读写128个字节，程序

【单片机】DS2431芯片，读写128个字节，程序

ds2431pt&r stm32读写程序&#xff1a; 部分程序&#xff1a; #include "sys.h" #include "delay.h" #include "usart.h"#include <stdio.h> #include <stdlib.h> #include <string.h>#include "sys.h" #incl…
阅读更多...
二开的精美UI站长源码分享论坛网站源码 可切换皮肤界面

二开的精美UI站长源码分享论坛网站源码 可切换皮肤界面

二开的精美UI站长源码分享论坛网站源码 可切换皮肤界面 二开的精美UI站长源码分享论坛网站源码 可切换皮肤界面
阅读更多...
C语言入门系列：数据类型之字面量类型

C语言入门系列：数据类型之字面量类型

文章目录 一&#xff0c;什么是字面量二&#xff0c;字面量为什么需要类型&#xff1f;三&#xff0c;变量类型和字面量类型的区别1&#xff0c;作用不同2&#xff0c;方式不同 四&#xff0c;编译器如何推断字面量类型1&#xff0c;整数2&#xff0c;浮点数3&#xff0c;字面量…
阅读更多...
2024最新AI大模型-LLm八股合集（八）-Transformer模型

2024最新AI大模型-LLm八股合集（八）-Transformer模型

更多2024最新AI大模型-LLm八股合集可以拉到文末&#xff01;&#xff01;&#xff01; MHA & MQA & MGA &#xff08;1&#xff09;MHA 从多头注意力的结构图中&#xff0c;貌似这个所谓的多个头就是指多组线性变换层&#xff0c;其实并不是&#xff0c;只有使用了一…
阅读更多...
E36150系列 自动量程台式电源

E36150系列 自动量程台式电源

E36150系列 自动量程台式电源 <<<KEYSIGHT是德科技>>> “ Keysight E36150 系列自动量程台式直流电源包含两个型号&#xff0c;其单通道输出功率可达 800 W。 E36150 系列可输出高达 60 V 的电压和 80 A 的电流&#xff0c;其可用功率足以满足您的测试需…
阅读更多...
360vr党建线上主题展立体化呈现企业的文化理念和品牌形象

360vr党建线上主题展立体化呈现企业的文化理念和品牌形象

在现代科技的引领下&#xff0c;艺术与VR虚拟现实技术相融合必将成为趋势&#xff0c;深圳VR公司华锐视点荣幸地推出VR艺术品虚拟展厅&#xff0c;为您带来前所未有的艺术观赏体验。体验者足不出户即可置身于一个充满创意与灵感的虚拟艺术空间。 我们深入了解每一位客户的需求与…
阅读更多...
maven archetype项目构架

maven archetype项目构架

1、设置环境变量 set MAVEN_HOMED:\SF\java\apache-maven-3.6.3 set path%path%;%MAVEN_HOME%\bin;2、制作archetype mvn -s "D:\SF\java\apache-maven-3.6.3\conf\settings.xml" archetype:create-from-project -DpackageNamecom.demo.esb-s:指定maven的setting文…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023