免备案域名购买网站/怎么建造自己的网站

【JavaEE】线程安全

一、引出线程安全
二、引发线程安全的原因
三、解决线程安全问题
- - 3.1 synchronized关键字（解决修改操作不是原子的）
  - - 3.1.1 synchronized的特性
    - 3.1.1 synchronized的使用事例
  - 3.2 volatile 关键字（解决内存可见性）
四、死锁
- - 4.1 可重入
  - 4.2 两个线程出现的死锁
  - 4.3 哲学家就餐问题
  - 4.4 造成死锁的原因

博客结尾有此篇博客的全部代码！！！

一、引出线程安全

举例：

public class Demo1 {private static int count=0;public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(()->{for (int i = 0; i < 50000; i++) {count++;}});Thread t2 = new Thread(()->{for (int i = 0; i < 50000; i++) {count++;}});t1.start();t2.start();t1.join();t2.join();System.out.println("count="+count);//结果：56154}
}

这段代码运行结束发现结果不是理论值：100000，而是每次运行完出现一个新的数。

在计算机操作系统中，count++；在寄存器中分为三步：读取，加一，写回这三步。

假设：两个线程按照这样进行，那么得到的count的最终值就是理论值100000。
在这里插入图片描述
但往往事实不是这样这样的，CPU资源调度是随机的！！！很有可能是这样的（这里只列举一种情况给大家示范一下）：

首先t1线程和t2 线程分别从内存中读取count值，此时两个线程读取到的count值都是0，然后t1线程进行加一操作后写回到内存中，t2线程也是进行加一操作后写回到内存中，t2线程得到的count值将t1得到的count覆盖，这样count经过两个线程的加一操作之后值还是1！
在这里插入图片描述

二、引发线程安全的原因

【根本原因】操作系统对于线程的调度是随机的，抢占式执行
多个线程同时修改同一变量
修改操作不是原子的（事务中的原子性）
内存可见性，引起的线程不安全
指令重排序，引起的线程不安全

三、解决线程安全问题

由于线程调度是随机的，这个不是我们可以左右的；
我们确保多个线程不同时修改同一变量

主要带大家学习引发第三个和第四个引起线程安全的解决方法：

3.1 synchronized关键字（解决修改操作不是原子的）

引发线程安全第三个原因是：修改操作不是原子的；关键字：synchronized将修改操作“锁”在一起（相当于将读取，加一，写回三个操作绑定在一起，三操作要么全部执行，要么全部不执行）
在这里插入图片描述

3.1.1 synchronized的特性

互斥
synchronized 会起到互斥效果, 某个线程执⾏到某个对象的 synchronized 中时, 其他线程如果也执⾏到同⼀个对象 synchronized 就会阻塞等待.
语法：

synchronized(变量){
//修改操作
}

在这里插入图片描述

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

public class Demo2 {private static int count = 0;public static void main(String[] args) throws InterruptedException {Object lock = new Object();Thread t1 = new Thread(() -> {for (int i = 0; i < 50000; i++) {synchronized (lock){count++;}}}); Thread t2 = new Thread(()->{for (int i = 0; i < 50000; i++) {synchronized (lock){count++;}}});t1.start();t2.start();t1.join();t2.join();System.out.println("count="+count);//结果：count=10000}
}

当加上锁之后，count值就是10000！
这里需要注意的事：
synchronized(变量)里面的这个变量必须是相同的变量，否则就不会发生阻塞等待！！！
事例：

public class Demo3 {private static int count = 0;public static void main(String[] args) throws InterruptedException {Object lock1 = new Object();Object lock2 = new Object();Thread t1 = new Thread(() -> {for (int i = 0; i < 50000; i++) {synchronized (lock1){count++;}}}); Thread t2 = new Thread(()->{for (int i = 0; i < 50000; i++) {synchronized (lock2){count++;}}});t1.start();t2.start();t1.join();t2.join();System.out.println("count="+count);//结果：count=70738}}

可重入
可重入就是指一个线程连续针对一个对象加多次锁，不会出现“死锁”现象称为可重入。

synchronized (block) {synchronized(block) {//代码} //右大括号}2
}  //右大括号}1

按理来说，在进入第一个synchronized的时候，加上了一把锁，此时已经是“锁定状态”，当我们进入到第二个synchronized的时候要加锁，就发生“阻塞等待”，就要等到第一个锁走到右大括号}1解完锁才能加，然而第一个锁走到右大括号}1解锁，又需要第二把锁创建走完到右大括号}2。
这是线程就卡死了，这就是死锁。

Java大佬发现了这个问题，所以将synchronized设为可重入锁，这样就不会出现死锁的问题。
• 如果某个线程加锁的时候, 发现锁已经被⼈占⽤, 但是恰好占⽤的正是⾃⼰（这个锁是自己加的）, 那么仍然可以继续获取到锁, 并让计数器⾃增.
• 解锁的时候计数器递减为 0 的时候, 才真正释放锁. (才能被别的线程获取到)

3.1.1 synchronized的使用事例

修饰代码块
锁定任意对象

锁住当前对象

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

直接修饰普通⽅法

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

修饰静态⽅法

public class SynchronizedDemo {public synchronized static void methond() {}}

3.2 volatile 关键字（解决内存可见性）

volatile可以保证内存可见性，只能修饰变量。并且volatile不能保证原子性

计算机运行代码/程序的时候，访问数据常常要从内存中访问（定义变量时变量就储存在内存中），然而CPU从内存中读取数据相比于从寄存器中读取数据要慢上很多（几千上万倍），CPU在进行读/写内存的时候速度就会降低。

为了解决这个问题，提高效率，编译器就可能会对代码优化，把一些本来要读取内存的操作，优化为读取寄存器，减少读取内存的次数。这就会导致内存可见性问题。

以我们接下来的代码为例------当CPU从自身寄存器中读取成千上万次发现count一直是0，此时编译器就将代码优化，让count一直等于0，所以接下来线程1中一直处于循环状态，尽管线程2中已经将count修改为1！

public class Demo4 {private static int count = 0;public static void main(String[] args) throws InterruptedException {Object lock1 = new Object();Thread t1 = new Thread(() -> {while (count == 0) {}System.out.println("循环结束");});Thread t2 = new Thread(() -> {try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}count = 1;});t1.start();t2.start();System.out.println("main 线程结束");}
}

这里修改的方法：给线程1中的程序加入sleep，让它休眠时间大于线程2的休眠时间，这样它读取的count就是1，编译器就不会进行优化，循环就会结束！

Thread t1 = new Thread(() -> {try {Thread.sleep(2000);} catch (InterruptedException e) {throw new RuntimeException(e);}while (count == 0) {}System.out.println("循环结束");});Thread t2 = new Thread(() -> {try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}count = 1;});

volatile解决内存可见性问题：

public class Demo5 {private volatile static int count = 0;public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(() -> {while (count == 0) {}System.out.println("循环结束");});Thread t2 = new Thread(() -> {try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}count = 1;});t1.start();t2.start();System.out.println("main 线程结束");}
}

四、死锁

死锁是一个非常严重的bug，它会让你的代码在执行到这块卡住！！！

4.1 可重入

public class Demo6 {private static int count = 0;public static void main(String[] args) throws InterruptedException {Object lock = new Object();Thread t1 = new Thread(() -> {for (int i = 0; i < 50000; i++) {synchronized (lock) {synchronized (lock) {count++;}}}System.out.println("循环结束");});t1.start();t1.join();System.out.println(count);}
}

由于Java提出了可重入的概念，所以这段代码执行的到这里并没有卡住！但在C++中，没有引入可重入的概念，所以C++这里写出这样的代码就会出现死锁！！！

4.2 两个线程出现的死锁

假设t1线程先拿醋，t2线程先拿酱，两个线程都将醋和酱已经加上自己的锁了，然后t1线程尝试拿酱，t2线程尝试拿醋，此时就会出现死锁！！！

public class Demo7 {public static void main(String[] args) throws InterruptedException {Object lock1 = new Object();Object lock2 = new Object();Thread t1 = new Thread(() -> {synchronized (lock1) {System.out.println("t1拿到醋了！！！");synchronized (lock2) {System.out.println("t1拿到酱了！！！");}}});Thread t2 = new Thread(() -> {synchronized (lock2) {System.out.println("t2拿到酱了！！！");synchronized (lock1) {System.out.println("t2拿到醋了！！！");}}});t1.start();t2.start();t1.join();t2.join();System.out.println("main 线程结束！！！");}
}

如果将两个锁改成并列就不会出现死锁！

     Thread t2 = new Thread(() -> {synchronized (lock2) {System.out.println("t2拿到酱了！！！");}synchronized (lock1) {System.out.println("t2拿到醋了！！！");}});

4.3 哲学家就餐问题

相当于是两个线程出现死锁的进阶（M个线程，N把锁）：
5个哲学家（5个线程），5只筷子（5把锁），哲学家坐在圆桌边，桌上放有面条，每只筷子放在每个哲学家的中间。
在这里插入图片描述

每个哲学家，会做两件事：

思考人生.放下筷子，啥都不干
吃面条.拿起左右两侧的两根筷子，开始吃面条，

哲学家啥时候吃面条，啥时候思考人生，是随机的
哲学家吃面条啥时候吃完，也是随机的，
哲学家正在吃面条的过程中，会持有左右两侧的筷子。此时相邻的哲学家如果也想吃面条，就需要阻塞等待，
当出现极端情况，每个哲学家都想吃面条，都拿起自己左手边的筷子，并且不会在没吃到面条情况下放下筷子，这时就是死锁了。

4.4 造成死锁的原因

互斥使用（锁的基本特性）：当一个线程拿到一把锁后，另一个线程要拿到这把锁就要阻塞等待；
不可抢占（锁的基本特性）：当一把锁被线程拿到后，其他线程不能抢占，只能等线程自己释放锁；
请求保持（代码结构）：当一个线程拿到一把锁后，再去拿其它锁的时候，已经被拿到的锁不会被释放；
循环/环路等待（代码结构）：阻塞等待的依赖关系形成环了。

此篇博客的全部代码！！！