《JavaEE篇》--多线程(2)

《JavaEE篇》--多线程(1)

线程安全

线程不安全

我们先来观察一个线程不安全的案例:

public class Demo {private static int count = 0;public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(() -> {//让count自增5W次for (int i = 0; i < 50000; i++) {count++;}});Thread t2 = new Thread(() -> {//让count自增5W次for (int i = 0; i < 50000; i++) {count++;}});t1.start();t2.start();//如果没有join,线程还没执行完,就会打印countt1.join();t2.join();//预期结果应该是十万次System.out.println("count: " + count);}
}

两个线程同时对一个变量进行修改,按理来说最后的输出结果应该是十万,现在我们运行一下

可以以看到似乎并不像我们预期的那样,每个结果都不一样,而且有些结果和我们预期的相差很大。

上述代码如果放在单线程里肯定是对的,但是如果放在多线程里就会出现逻辑错误了

先要知道怎么回事我们要先了解一下count++这个操作。

Count++这个操作实际上,是分成三步进行的,站在cpu的角度上,count++是由cpu通过三条指令来实现的

  1. load 把数据从内存读到cpu寄存器上
  2. add  把寄存器中的数据+1
  3. save 把寄存器中的数据,保存到内存中

 由于线程之间的调度顺序是随机的,就会导致在有些调度顺序下,就会出现上述逻辑错误,接下来我通过画图的方式详细讲解。

上述两种执行顺序是正常的执行顺序(t1线程执行完整个count++动作,之后t2线程再执行,或者t2先执行),但是由于线程的随机调度,可能当t1执行load和add的操作之后,这时t2插了进来完成自己的操作。就像这样

那么此时会产生什么结果呢?

可以看见此时编译器执行了两次count++操作但是实际的count只被加了一次,这还只是一种顺序,实际编译时两个操作执行count++又会有多少种呢?如果t1执行一次,t2执行两次,三次呢又会有多种?必然是我们无法知晓的。

结合上述讨论,就意识到了,在多线程中最困难的一点就是:线程的随机调度,使两个线程执行逻辑的先后顺序存在诸多可能,我们要保证在所有可能的情况下,代码都是正确的。

 综上对于线程安全我们可以粗略的认为:如果多线程环境下代码运行的结果是符合我们预期的,即在单线程环境应该的结果,则说这个程序是线程安全的。 

 线程不安全的原因

线程安全产生的原因主要有以下五点

  1. 操作系统中,线程的调度是随机的(抢占式执行)//主要原因
  2. 两个或多个线程对同一个变量进行修改
  3. 修改操作不是原子性的(比如count++就是非原子操作,需要多条指令才能完成操作)
  4. 内存可见性问题(之后讲到)
  5. 指令重排序(之后讲到)

 原子性:原子性不一定只是一条java语句或者只是一条cpu指令,如果一个操作在执行的时候不会有其他操作干扰或插入,就可以说这个操作是具有原子性的,比如如果把刚刚的count++加上一把锁让编译器,必须执行完一个count++后才能执行下一个count++,这样不管t1,t2线程的执行顺序如何,都不会影响最后结果。

保证原子性这一点也和线程的抢占式调度密切相关,如果线程不是抢占式(随机)的,就算没有原子性也没有什么关系

那么我们如何保证线程是安全的?我们先暂时针对前三个问题进行解决,先看第一个,这是操作系统的特性我们不好对其进行修改, 那么再看后两个,如果我们保证操作是原子性的,这样不管对变量怎么修改,就都不会出错了。那么怎么保证原子性呢?最好的方法就是加锁

加锁

我们先来解决刚刚的代码

 private static int count = 0;public static void main(String[] args) throws InterruptedException {Object locker = new Object();Object locker2 = new Object();Thread t1 = new Thread(() -> {//让count自增5W次for (int i = 0; i < 50000; i++) {synchronized (locker){//当同时对一个对象加锁时,必须要等前一个代码块执行完,后一个代码块才能执行,就可以解决问题了count++;}}});Thread t2 = new Thread(() -> {//让count自增5W次for (int i = 0; i < 50000; i++) {synchronized (locker){count++;}}});t1.start();t2.start();//如果没有join,线程还没执行完,就会打印countt1.join();t2.join();//预期结果应该是十万次System.out.println("count: " + count);}

运行结果:

可以看见现在的结果正是我们预期的

synchronized

synchronized 会起到互斥效果, 某个线程执行到某个对象的 synchronized 中时, 其他线程如果也执行到 同一个对象 synchronized 就会阻塞等待,换言之,当两个synchronized同时对一个对象加锁(什么样对象一般无所谓只要是相同的就行),必须要等前一个synchronized代码块执行完,后一个代码块才能执行。

  • 进入 synchronized 修饰的代码块, 相当于 加锁
  • 退出 synchronized 修饰的代码块, 相当于 解锁

举个例子🌰:

如果A对B表白,并且B同意了此时就相当于A对对象B进行了加锁,此时C就不能再追求B了,只能等A和B分手后(解锁),B又回归单身后,此时C就可以光明正大的追求B了。

//synchronized用的锁是存在Java对象头里的,加锁就相当于对对象头进行了修改

可以粗略的理解成对象再内存中储存的时候,都有一块内存表示对象是否被锁,如果被锁则其他线程不能再次加锁,如果没被锁则可以加锁。

其他写法

这两种方法等价

 //这两种方法等价synchronized public void add1(){this.count++;}public void add2(){synchronized (this){count++;}}
//这两种方法等价synchronized public static void add3(){}public static void add4(){synchronized (Count.class){}}

这两种方法也等价,上面的写法相当于下面的简化写法 

Count.class叫做类对象,类对象在java进程中是唯一的,一般包含以下内容

  1. 类的属性有哪些,都是啥名字,类型,权限
  2. 类的方法有哪些,都是啥名字,类型,权限
  3. 类本身继承自哪个类,实现了什么接口

 可重入

  • 不可重入锁:只判断这个锁有没有被锁上,如果没被锁上就可以对其加锁,如果被锁上就要等待它解锁之后才可以加锁
  • 可重入锁:不仅会判断这个锁有没有被锁上,还会判断这个锁是被谁锁上的,如果是被当前线程锁上的则可以连续加锁,并且不出现死锁

简单来说一个线程,连续针对一个一把锁,加锁两次,不会出现死锁,满足这个要求,就是可重入

不可重入锁

当一个代码块被锁上,此时如果在代码块内部再加上一把锁就会出现死锁,如下

如果synchronized是不可重复锁,针对上述代码,在第一次加锁时可以成功,此时locker已近是被加锁的状态了,当进行第二次加锁时,因为locker已经被加锁了所以第二把锁就会阻塞等待,要等到第一把锁解锁之后才能加成功。但是实际上,一旦第二把锁阻塞等待了,就会出现死锁,因为第一把锁要想解锁就要执行到(1)的位置,要想执行到(1)的位置就要让第二把锁成功加锁,由于第二次加锁导致代码阻塞了,就没办法执行到(1)的位置了也就没办法释放锁了。

//死锁的发生不一定是在一个方法,也可能会发生在方法调用之间

 可重入锁

可重入锁是一种支持可重入机制的锁,当对一把锁连续加锁两次第二把锁不会出现阻塞(换言之,外层使用锁之后,内层任然可以使用),允许一个线程反复获得该锁,避免了死锁的发生,同时也提高了代码的简洁性的可读性,我们刚刚讲到的synchronized就是可重入锁

我们在对这个案例进行分析,因为synchronized是可重入锁,所以没有因为第二次加锁而死锁,但是当代码执行到(2)时,此时,锁(1)应不应该打开?又或者说,这里有N把锁,那么释放的时机应该如何?

为了解决这个问题,可重入锁设计了加锁次数,每加一次锁就加1,释放一次锁就减1,当计数为0时才真正释放锁,以此来保证所有的加锁过程都解锁了,其他线程才能访问。

在可重入锁的内部, 包含了 "线程持有者" 和 "计数器" 两个信息.

  • 如果某个线程加锁的时候, 发现锁已经被人占用, 但是恰好占用的正是自己, 那么仍然可以继续获取 到锁, 并让计数器自增.
  • 解锁的时候计数器递减为 0 的时候, 才真正释放锁. (才能被别的线程获取到)

关于死锁

1.一个线程针对一把锁,连续加锁两次,如果是不可重入锁,就会发生死锁

2.两个线程,两把锁,t1线程先获取锁A在获取锁B,t2线程先获取锁B在获取锁A(此时无论是不是可重入锁都会死锁),就相当于一个人把车钥匙锁在家里,把家里钥匙锁在车里

 3.N个线程M把锁

关于N个线程M把锁有一个经典的模型--哲学家就餐问题

哲学家就餐问题

规则是这样的:

  • 每个哲学家会做两件事1.思考人生,放下筷子啥也不干  2.吃面条,拿起左右两侧的筷子,开始吃面条
  • 哲学家什么时候吃面条,什么时候思考人生是随机的
  • 哲学家什么时候吃完面条,什么时候思考完人生也是随机的
  • 哲学家正在吃面条时会拿起左右两则的筷子,如果相邻的哲学家也想吃面条就需要阻塞等待

 基于上述规则通常情况下,是可以正常运行的,但是当处在极端情况下时,比如五位哲学家同时想吃面,又同时拿起左边的筷子,这时就会出现死锁的情况(这里哲学家就相当于一个线程,筷子就相当于是锁,拿起一个筷子相当于解开了一把锁)。

处理方法:

  1. 对哲学家进行限制,当哲学家确认左右两边的筷子都可以用时才会拿起筷子吃面(确认之后其他人不会再拿起),使拿起筷子这个操作成为一个原子性的,就可以避免死锁发生。
  2. 找到一位右撇子的哲学家(先拿起右边的筷子,其他人都是左撇子),目的是让这个哲学家拿筷子的顺序和其它人不一样,当其他哲学家都拿起左边的筷子时,此时这个哲学家右边就没有筷子了,就处于阻塞等待,此时就会有一个哲学家成功拿到两双筷子。
  3. 限制吃饭的人数,方法很简单,就是在一个时间点最多只能有4个哲学家进餐,这样4个让分5双筷子,一定能有人吃的到,就不会发生死锁。
  4. 规定一个哲学家只有在两个相邻的哲学家都不吃面的情况下,才可以吃面,这样就彻底解决了死锁问题,和第一种方法有点类似。

Volatile

内存可见性

线程之间的共享变量存在主内存(实际物理内存)中,而且每一个线程还有自己的工作内存(寄存器/cpu高速缓存),当线程要读取一个共享变量时,会把变量从主内存拷到工作内存中,再从工作内存读取数据,当线程要修改一个共享变量时,也会先修改工作内存中的副本,在同步到主内存中。这样可能就会导致线程1修改了共享变量a,但是主内存和线程2中数据更改不及时。

内存可见性会带来的问题

我们先来看段代码

正常来将当我们输入1时t1线程就结束了

但是实际上无论我们如何输入1,t1都没有结束,这是怎么回事?

计算机运行的程序,经常要访问数据,这些数据往往会存储在内存中(比如,定义一个变量,变量就会存储在内存中),当cpu使用这个变量的时候,就会把这个变量,先从内存中读出来,再放到cpu的寄存器中,最后在参与运算。cpu读取内存的操作是比较缓慢的,相对而言读寄存器就快的多了。

为了及解决上述问题,提高效率,此时编译器就可能对代码作出一些优化,把一些本来要读内存的操作,转化为读寄存器,减少读内存的次数,也就提高了程序的效率了

当编译器在处理isQuit == 0时会涉及到俩条指令1.load读取内存中的isQuit的值到寄存器中,2.通过cmp指令比较寄存器里的值是不是0,然后决定要不要循环。

由于循环执行的速度非常快,短时间内就会完成大量load和cmp操作。这时编译器/JVM就会发现,虽然进行了这么多次load,但是每次load的结果都一样,并且load操作非常消耗时间,比cmp操作消耗的时间多得多,于是编译器就做了一个大胆的就决定,只在第一次循环操作的时候,才读内存,后续都不在读内存了,而是直接从寄存器中取出isQuit的值,这个就是编译器的优化。

编译器是希望代码能够更高效,才在保证代码逻辑不变的情况下,对代码进行优化,但是,此时我们是由另外一个线程对isQuiti进行了修改,编译器没有做出正确的判断,以为没人修改,最终导致了bug,这个问题就是内存可见性问题。

这时我们可以利用Volatile来解决这个问题

在多线程的环境下,编译器有时会做出一些不准确的优化,此时就需要我们程序猿自己手动来矫正。我们可以通过Volatile关键字,来告诉编译器不要进行优化。我们直接在刚刚的代码上操作,直接在isQuit前加上Volatile就行。

运行结果

可以看到这时程序成功执行

wait和notify

wait():让当前线程等待阻塞

wait的工作过程是,释放当前的锁,使当前的线程进行等待,满足唤醒条件后,重新尝试获得这把锁(wait必须搭配synchronized使用,换言之当前线程必须得到锁,否则直接使用的化会抛出异常)

wait可以传参,表示最多等待的时间(ms)

notify():唤醒wait等待的线程

notify工作过程是,唤醒wait,然后解锁

  • 方法notify()也要在同步方法或同步块中调用,该方法是用来通知那些可能等待该对象的对象锁的 其它线程,对其发出通知notify,并使它们重新获取该对象的对象锁。
  • 如果有多个线程等待,则有线程调度器随机挑选出一个呈 wait 状态的线程。(并没有 "先来后到")
  • 在notify()方法后,当前线程不会马上释放该对象锁,要等到执行notify()方法的线程将程序执行 完,也就是退出同步代码块之后才会释放对象锁。
  • 和wait一样必须搭配synchronized使用

notifyAll():可以一次唤醒所有的等待线程.

使用:

 public static void main(String[] args) {Object locker = new Object();Thread t1 = new Thread(() -> {System.out.println("wait 之前");synchronized (locker){try {locker.wait();} catch (InterruptedException e) {throw new RuntimeException(e);}}System.out.println("wait之后");});Thread t2 = new Thread(() -> {try {Thread.sleep(3000);} catch (InterruptedException e) {throw new RuntimeException(e);}synchronized (locker){System.out.println("进行通知");locker.notify();}});t1.start();t2.start();}

wait和sleep的区别

不同点:

  • wait 需要搭配 synchronized 使用. sleep 不需要.
  • wait 是 Object 的方法 sleep 是 Thread 的静态方法.
  • wait是为了让线程稍作等待,避免线程盲目争夺资源,sleep这时单纯让线程休眠一段是时间
  • wait是用于线程之间的通信,sleep只是用于让线程阻塞一段时间
  • 线程在wait时会释放锁,在sleep时不会
  • wait线程处于WAITING状态,sleep时线程处于TIMED_WAITING状态
  • wait被notify提前唤醒不会报出异常,sleep被提前唤醒会报异常
  • 相同点:
  • 都会让线程阻塞一段时间
  • 都可以设置最大等待时间时间

以上就是博主对线程知识的分享,在之后的博客中会陆续分享有关线程的其他知识,如果有不懂的或者有其他见解的欢迎在下方评论或者私信博主,也希望多多支持博主之后和博客!!🥰🥰

下一篇博客博主将分享有关单例模式等知识,还希望多多支持一下!!!😊

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

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

相关文章

HarmonyOS网络请求的简单用法,HttpUtil简单封装

请求网络获取数据 点击按钮发送一个post请求&#xff0c;发送一条string由于此处的返回result.data本身就是一个string&#xff0c;因此不需要转换类型 Button(请求网络).margin({ top: 10 }).fontSize(24).fontWeight(FontWeight.Bold).onClick(() > {httpRequestPost(http…

JVM 内存结构、垃圾回收机制与并发容器

目录 一、JVM 内存结构 1. 程序计数器&#xff08;Program Counter Register&#xff09;&#xff1a; 2. Java 虚拟机栈&#xff08;JVM Stack&#xff09;&#xff1a; 3.本地方法栈&#xff08;Native Method Stack&#xff09;&#xff1a; 4.堆&#xff08;Heap&#xff…

Android笔试面试题AI答之控件Views(6)

答案来着文心一言&#xff0c;仅供参考 目录 1.简述什么是RemoteViews?使用场景有哪些?RemoteViews的特性使用场景总结 2.获取View宽高的几种方法?1. 在onWindowFocusChanged方法中获取2. 使用ViewTreeObserver.OnGlobalLayoutListener3. 使用ViewTreeObserver.OnPreDrawLi…

风格迁移开发记录(DCT-Net)

1.DCT-Net部署 阿里旗下的 modelscope社区&#xff0c;丰富的开源风格迁移算法模型 DCT-Net GitHub链接 git clone https://github.com/menyifang/DCT-Net.git cd DCT-Netpython run_sdk.py下载不同风格的模型如下图每个文件夹代表一种风格&#xff0c;有cartoon_bg.pb, car…

C++STL详解(一)——String接口详解(上)!!!

目录 一.string类介绍 二.string类的构造赋值 2.1string类的拷贝和构造函数 2.2深拷贝 三.string类的插入 3.1push_back 3.2append 3.3操作符 3.4insert 四.string的删除 4.1pop_back 4.2erase 五.string的查找 5.1find 5.2rfind 六.string的比较 6.1compare函…

独家|二十年国货羊奶粉老品牌发力成人奶粉,瞄准低GI、特医食品

前言 中国羊奶看陕西。 作为陕西省农业产业化重点企业以及陕西省专精特新企业&#xff0c;成立于2004年的羊奶粉品牌雅泰乳业正在不断进行深入布局。 雅泰乳业成人粉部门销售总监于维涛近日向AgeFood表示&#xff0c;雅泰成人奶粉业务主要分为两部分。一部分是以雅泰牧歌、龙…

深入浅出WebRTC—Pacer

平滑发包&#xff08;Pacer&#xff09;是 WebRTC 实现高质量实时通信不可或缺的一部分。在视频通信中&#xff0c;单帧视频可能包含大量的数据&#xff0c;如果未经控制地立即发送&#xff0c;可能瞬间对网络造成巨大压力。Pacer 能够根据网络条件动态调整发送速率&#xff0c…

SpringBoot事务管理、任务调度、Mail整合。

一.Spring Boot中的事务管理 编程式事务 : 在代码中硬编码(不推荐使用):通过 TransactionTemplate 或者 TransactionManager 手动管理事务&#xff0c;实际应用中很少使用&#xff0c;用于理解Spring 事务管理。 声明式事务:在 XML 配置文件或者基于注解 Transactional(推荐使…

Java实现汉字转拼音工具类的编写与应用

前言 在处理中文数据时&#xff0c;经常需要将汉字转换为拼音&#xff0c;无论是为了搜索优化、数据分析还是提升用户体验。本文将详细介绍如何编写一个实用的Java工具类来实现这一功能&#xff0c;并通过一个完整的示例来展示其使用方法。我们将使用Apache Commons Lang库中的…

缓慢变化维

缓慢变化维 缓慢变化维&#xff08;Slowly Changing Dimensions&#xff0c;简称SCD&#xff09;是数据仓库中的一个重要概念&#xff0c;用于处理维度表中数据随时间发生的变化。以下是一个具体的例子来描述缓慢变化维&#xff1a; 假设我们有一个销售数据仓库&#xff0c;其…

AWS全服务历史年表:发布日期、GA和服务概述一览(四)

我一直在尝试从各种角度撰写关于Amazon Web Services&#xff08;AWS&#xff09;的信息和魅力。由于我喜欢技术历史&#xff0c;这次我总结了AWS服务发布的历史年表。 虽然AWS官方也通过“Whats New”发布了官方公告&#xff0c;但我一直希望能有一篇文章将公告日期、GA日期&…

python库(14):Arrow库简化时间处理

1 Arrow简介 Arrow 是一个被称为程序员的时间处理利器的 Python 库。 从诞生起&#xff0c;它就是为了填补 Python 的 datetime 类型的功能空白而生的。为程序员提供了一种更简单、更直观的方式来处理日期和时间。 2 安装Arrow库 pip install arrow -i https://pypi.tuna.ts…

什么是设备运维管理系统?有什么作用?(6款设备运维管理系统推荐)

一、什么是设备运维管理系统&#xff1f; 设备运维管理系统是一种集成了监控、管理、维护和优化设备性能的软件平台。它旨在通过自动化的手段&#xff0c;提高设备运行的可靠性和效率&#xff0c;降低运维成本&#xff0c;并优化资源利用。 设备运维管理系统能够实时监控设备…

【1】Python机器学习之基础概念

1、什么是机器学习 最早的机器学习应用——垃圾邮件分辨 传统的计算机解决问题思路&#xff1a; 编写规则&#xff0c;定义“垃圾邮件”&#xff0c;让计算机执行对于很多问题&#xff0c;规则很难定义规则不断变化 机器学习在图像识别领域的重要应用&#xff1a; 人脸识别…

带您详细了解安全漏洞的产生和防护

什么是漏洞&#xff1f; 漏洞是 IT、网络、云、Web 或移动应用程序系统中的弱点或缺陷&#xff0c;可能使其容易受到成功的外部攻击。攻击者经常试图寻找网络安全中的各种类型的漏洞来组合和利用系统。 一些最常见的漏洞&#xff1a; 1.SQL注入 注入诸如 SQL 查询之类的小代…

c# Math.Round()四舍五入取整数

可以使用Math.Round()方法进行四舍五入取整数的操作。 以下是使用Math.Round()方法的实现方法&#xff1a; 将浮点数直接作为参数传递给Math.Round()方法&#xff0c;并指定要保留的小数位数。此方法将返回最接近的整数值。 double number 3.89; int roundedNumber (int)Mat…

react-scripts 这个包的作用是什么

react-scripts 是 Create React App 项目中的一个核心包&#xff0c;它的主要作用包括: 封装和简化项目配置。react-scripts 封装了 Webpack、Babel、ESLint 等工具的配置&#xff0c;使开发者无需手动配置这些复杂的构建工具[1][3]. 提供开发和构建脚本。它包含了 start、bui…

milvus的批量向量搜索

批量向量搜索允许在单个请求中进行多个向量相似性搜索。这种类型的搜索非常适合需要为一组查询向量查找相似向量的场景&#xff0c;可显著减少所需的时间和计算资源。 即:一次查询多个向量&#xff0c;吞吐。 系统会并行处理这些向量&#xff0c;为每个查询向量返回一个单独的…

旋转目标检测:FCOS: Fully Convolutional One-Stage Object Detection【方法解读】

FCOS: 全卷积单阶段目标检测 我们提出了一种全卷积单阶段目标检测器(FCOS),以逐像素预测的方式解决目标检测问题,类似于语义分割。目前几乎所有的最先进目标检测器,如RetinaNet、SSD、YOLOv3和Faster R-CNN,都依赖于预定义的锚框。相反,我们提出的FCOS检测器是无锚框的…

静态解析activiti文本,不入库操作流程

说明&#xff1a; activiti本身状态存库&#xff0c;导致效率太低&#xff0c;把中间状态封装成一个载荷类&#xff0c;返回给上游&#xff0c;下次请求时给带着载荷类即可。 1.pom依赖 <dependency><groupId>net.sf.json-lib</groupId><artifactId>js…