线程安全(重点)

news/2024/10/28 1:14:24/

文章目录

  • 一.线程安全的概念
    • 1.1 线程安全的概念
    • 1.2 线程不安全的原因
    • 1.3 解决线程不安全
  • 二.synchronized-monitor lock(监视器锁)
    • 2.1 synchronized的特性
      • (1)互斥
      • (2)刷新内存
      • (3)可重入
    • 2.2 synchronied使用方法
      • 1.直接修饰普通方法:
      • 2.修饰静态方法:
      • 3.修饰代码块:
  • 三.死锁
    • 3.1死锁的情况
    • 3.2 死锁的四个必要条件
      • 1.互斥使用
      • 2.不可抢占
      • 3.请求和保持
      • 4.循环等待
    • 3.3解决死锁的办法
  • 四.volatile 关键字
  • 五. wait和notify
    • 5.1 wait()方法
    • 5.2 notify()方法

一.线程安全的概念

先来看一段代码

class Counter{public int count = 0;public void add(){count++;}}
public class Thread14 {public static void main(String[] args) throws InterruptedException {Counter counter = new Counter();Thread t1  = new Thread(()->{for (int i = 0; i < 50000; i++) {counter.add();}});Thread t2 = new Thread(() ->{for (int i = 0; i < 50000; i++) {counter.add();}});t1.start();t2.start();t1.join();t2.join();System.out.println("count = "+ counter.count);}
}

可以看到结果是不确定的

在这里插入图片描述
这里是引用

1.1 线程安全的概念

先来说一下非线程安全的概念:非线程安全主要是指多个线程对同一个对象中的同一个实例变量进行操作时会出现值被更改、值不同步的情况，进而影响程序的执行流程。
则线程安全:如果多线程环境下代码运行的结果是符合我们预期的，即在单线程环境应该的结果，则说这个程序是线程安全的。

1.2 线程不安全的原因

先解释上述线代码程不安全的原因：
在这里插入图片描述

如果两个线程并发执行count++,此时就相当于两组load add save进行执行,此时不同的线程调度顺序就可能会产生一些结果上的差异

由于线程的抢占执行,导致当前执行到任意一个指令,线程都可能bei调度走,CPU让别的线程来执行
如下图:
在这里插入图片描述
导致下面的结果:
在这里插入图片描述
线程安全问题的原因:
1.抢占式执行,随机调度(根本原因)
2.代码结构:多个线程同时修改同一个变量
3.原子性(操作是非原子性,容易出现问题)
4.内存可见性问题(如一个线程读,一个线程改)
5.指令重排序

1.3 解决线程不安全

从原子性入手,通过加锁,把非原子的,转成"原子"的
在这里插入图片描述
加了synchronized之后,进入方法就会加锁,出了方法就会解锁,如果两个线程同时尝试加锁,此时一个能获取锁成功,另一个只能阻塞等待(BLOCKED),一直阻塞到刚才的线程解锁,当前线程才能加锁成功

二.synchronized-monitor lock(监视器锁)

2.1 synchronized的特性

(1)互斥

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

(2)刷新内存

synchronized的工作过程:

1.获得互斥锁
2.从内存拷贝变量的最新副本到工作的内存
3.执行代码
4.将更改后的共享变量的值刷新到主内存
5.释放互斥锁

(3)可重入

synchronized同步块对同一条线程来说是可重入的,不会出现自己把自己锁死的问题(自己可以再次获取自己的内部锁)
理解"把自己锁死"
一个线程没有释放锁,然后又尝试再次加锁
在这里插入图片描述
按照之前对于锁的设定,第二次加锁的时候,就会阻塞等待,而获取不到第一次的锁,就把自己锁死

2.2 synchronied使用方法

1.直接修饰普通方法:

锁的SynchronizedDemo1对象

public class SynchronizedDemo1 {public synchronized void methond() {}
}

2.修饰静态方法:

锁SynchronizedDemo2对象

public class SynchronizedDemo2 {public synchronized void methond() {}
}

3.修饰代码块:

明确指定锁哪个对象

public class SychronizedDemo{public void method(){sychronized(this){}}
}

锁类对象

public class SynchronizedDemo {public void method() {synchronized (SynchronizedDemo.class) {}}
}

三.死锁

3.1死锁的情况

1.一个线程,连续加锁两次,如果锁是不可重入锁,就会死锁
2.两个线程,两把锁,t1和t2各自先针对锁A和锁B加锁,在获取对方的锁

public class Thread15 {public static void main(String[] args) {Object lock1 = new Object();Object  lock2= new Object();Thread t1 = new Thread(()->{synchronized (lock1){try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}synchronized (lock2){System.out.println("t1把锁1和锁2都获得了");}}});Thread t2 = new Thread(()->{synchronized (lock2){try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}synchronized (lock1){System.out.println("t2把锁1和锁2都获得了");}};});t1.start();t2.start();}
}

在这里插入图片描述
3.多个线程,多把锁(相当于2的一般情况)

3.2 死锁的四个必要条件

1.互斥使用

线程1拿到了锁,线程2就须等着

2.不可抢占

线程1拿到锁A之后,必须是线程1主动释放

3.请求和保持

线程1拿到锁A之后,在尝试获取锁B,A这把锁还是保持的

4.循环等待

线程1尝试获取到锁A和锁B,线程2尝试获取锁B和锁A,线程1在获取B的时候等待线程2释放B,同时线程2 在获取A的时候等待线程1释放A

3.3解决死锁的办法

给锁编号,然后指定一个固定的顺序来加锁,任意线程加把锁,都让线程遵守上述顺序,此时循环等待自然破除

对于synchronied前三个条件都是锁的基本特性,我们只能对四修改

public class Thread15 {public static void main(String[] args) {Object lock1 = new Object();Object  lock2= new Object();Thread t1 = new Thread(()->{synchronized (lock1){try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}synchronized (lock2){System.out.println("t1把锁1和锁2都获得了");}}});Thread t2 = new Thread(()->{synchronized (lock1){try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}synchronized (lock2){System.out.println("t2把锁1和锁2都获得了");}};});t1.start();t2.start();}
}

在这里插入图片描述

四.volatile 关键字

volatile 和内存可见性问题密切相关

一个线程针对一个变量进行读取操作,同时另一个线程针对这个变量进行修改,此时读取到值,不一定是修改之后的值(归根结底是编译器/jvm在多线程下优化时产生了误判)

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
使用汇编语言解释
1.load,把内存中flag的值,读取到寄存器
2.cmp把寄存器的值和0进行比较,根据比较结果,决定下一不执行.
由于load执行速度太慢(相比于cmp来说),再加上反复load的结果都一样,JVM就不在重复load判定没人改flag值,就只读取一次就好
而给flag加上volatile关键字,告诉编译器变量是"易变"的,不再进行优化

class MyCounter{volatile public int flag = 0;
}
public class Thread16 {public static void main(String[] args) {MyCounter myCounter = new MyCounter();Thread t1 = new Thread(() ->{while (myCounter.flag == 0){//循环体空着}System.out.println("t1循环结束");});Thread t2 = new Thread(() ->{Scanner scanner = new Scanner(System.in);System.out.println("请输入一个整数:");myCounter.flag = scanner.nextInt();});t1.start();t2.start();}
}

结果:
在这里插入图片描述

五. wait和notify

wait和notify可以协调线程之间的先后顺序

完成这个协调工作, 主要涉及到三个方法

  • wait() / wait(long timeout): 让当前线程进入等待状态.
  • notify() / notifyAll():唤醒在当前对象上等待的线程.

注意: wait, notify, notifyAll 都是 Object 类的方法

5.1 wait()方法

wait的操作
1.先释放锁
2.在阻塞等待
3.收到通知之后,重新获取锁,并且在获取锁后,继续往下执行

wait操作需要搭配synchorized来使用

public class Thread17 {public static void main(String[] args) throws InterruptedException {Object object = new Object();System.out.println("wait之前");object.wait();System.out.println("wait之后");}
}

无synchorized的情况
在这里插入图片描述
wait无参数版本,就是死等
wait带参数版本,指定了等待的最大时间

5.2 notify()方法

notify()方法是唤醒等待线程

  • 如果有多个线程等待，则有线程调度器随机挑选出一个呈 wait 状态的线程。(并没有 “先来后到”)

  • 在notify()方法后，当前线程不会马上释放该对象锁，要等到执行notify()方法的线程将程序执行完，也就是退出同步代码块之后才会释放对象锁。

notfiyAll()方法可以一次唤醒所有的等待线程


http://www.ppmy.cn/news/33258.html

相关文章

在Intellij IDEA中使用Maven创建Java项目

在Intellij IDEA中使用Maven创建Java项目

1. Maven简介Maven是一个创建、管理Java项目的工具。它将项目开发和管理过程抽象成一个项目对象模型(POM&#xff1a;Project Object Model)。Maven项目结构如下&#xff1a;a-maven-project 项目名 ├── pom.xml 项目描述文件 ├── src │ ├── main │ │ ├─…
阅读更多...
Android 进程间通信机制(三) 系统进程与应用进程通信

Android 进程间通信机制(三) 系统进程与应用进程通信

一. 概述 Android中有一个重要的系统进程(system_server)&#xff0c;运行着系统中非常重要服务(AMS, PMS, WMS等)&#xff0c; 针对Activity而言&#xff0c;系统进程需要不断地调度Activity执行&#xff0c;管理Activity的状态; 每一个APK都需要运行在一个应用进程中&#xf…
阅读更多...
html+css 实现 熊猫样式

html+css 实现 熊猫样式

效果 html代码 <!DOCTYPE html> <html lang"en"> <head><meta charset"UTF-8"><meta name"viewport" content"widthdevice-width, initial-scale1.0"><meta http-equiv"X-UA-Compatible"…
阅读更多...
如何通过openssl生成公钥和私钥？

如何通过openssl生成公钥和私钥？

1、生成RSA秘钥的方法 生成RSA秘钥的方法&#xff1a; openssl genrsa -des3 -out privkey.pem 2048 注&#xff1a;建议用2048位秘钥&#xff0c;少于此可能会不安全或很快将不安全。 这个命令会生成一个2048位的秘钥&#xff0c;同时有一个des3方法加密的密码&#xff0c…
阅读更多...
Intel I210网卡

Intel I210网卡

I210 supports AVB and ETF (Earliest TxTime First, Time-Based Scheduling), but does not support TSN (802.1Qbv). I225 (IGC) supports TSN, each Tx queue has the start_time and end_time, they are within [0, cycle_time]. 1 Intel I210网卡 1.1 PHY配置 Intel的LAN芯…
阅读更多...
Python快速入门：类、文件操作、正则表达式

Python快速入门：类、文件操作、正则表达式

类、文件操作、正则表达式1. 类2. 文件操作3. 正则表达式1. 类 类是用来描述具有相同的属性和方法的集合&#xff0c;定义了该集合中每个对象共有的属性和方法&#xff0c;对象是类的实例&#xff0c;可以调用类的方法。 定义类时&#xff0c;如有父类&#xff0c;则写在类名…
阅读更多...
Linux中的标准IO【上】

Linux中的标准IO【上】

标准IO fopen() FILE * fopen(const char * restrict path, const char * restrict mode);第一个参数表示被打开文件路径&#xff0c;第二个参数表示打开文件模式—模式不同&#xff0c;对同一个文件有不同的更改r和r模式下不存在文件则也无法创建&#xff0c;其余模式若文件本…
阅读更多...
js类型转换

js类型转换

类型转换 1.字符串转换 字符串转换在原来值的基础上加上 "" let num 1 num String(num) // "1"String(false) // "false"2.数字转换 在算数函数和表达式中&#xff0c;会自动进行数字转换。其自动完成的数字转换为隐式转换&#xff0c;也可…
阅读更多...
最新文章

Copyright @ 2022~2023