何为线程安全？

要谈及何为线程安全，总得说来，我们可以用一句话来概况：

如果在多线程环境下代码运行结果和我们预期是相符的，即和单线程环境下的运行结果相同，那么我们就称这个程序是线程安全的，反之则不安全，即和预期不符；

为了大家更好地理解这句话，大家可以看一下下面这个例子

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

对于上述代码，我们预期的结果应该是输出10000，因为count经过了10000次的累加，然而事实上结果是....？

7019...??这样一个令人摸不着头脑的数字，甚至每次运行的结果都不一样，这是为什么呢？

原因分析：

实际上，count++的操作是分为三步的

1. load从内存中读取数据到cpu的寄存器
2. add把寄存器中的值+1
3. save把寄存器中的值写回内存中

而由于线程是随机调度的，所以有可能t1刚执行到第1一步，cpu资源就被调度走了，那么count值就不会和预想结果一样，也可能t1和t2同时执行第一步，那么它们读取到的数据都是count = 0，而事实上count应该执行的操作是 + 2，因为这样随机调度的不确定性，就使得这样的代码是线程不安全的！！

线程不安全的原因

1) 根本原因

线程不安全的根本原因就是线程的随机调度，这样的随机带来了很多不确定性，使得线程的执行顺序是不确定的~~

2) 多个线程修改同一个变量

通过例子我们可以发现，t1和t2都在针对count这一个变量进行修改的操作，这样的操作就会引起线程安全问题，为了解决这样的问题，我们就会引入"锁"这样的概念，具体的解释我们会在解决安全问题篇讲述~~

3) 修改操作不是原子的

何为原子的？

原子的即原子性的操作，即这个操作是不可再分的。

我们上文提到了，虽然我们肉眼看起来count++这个操作就是对count进行了一个加法操作，但事实上，count++这个操作是包含了三部分的，所以这个操作并不是一个原子性的操作~~因此引发了线程安全问题

4) 内存可见性问题

在讲述这个原因之前，我们要先引入另外一个例子

import java.util.Scanner;public class Demo22 {public static int flg = 0;public static void main(String[] args) {Thread t1 = new Thread(() -> {while (flg == 0) {}System.out.println("t1线程结束");});Thread t2 = new Thread(() -> {System.out.println("请输入flg的值：");Scanner scan = new Scanner(System.in);flg = scan.nextInt();});t1.start();t2.start();}
}

上述代码我们想实现的结果是，用户输入一个非0的数字后t1线程结束，然而真正的运行结果却无法结束t1线程

原因分析：

造成这样结果的原因就是因为t2修改了这个变量内存，但t1内却没有接收到这个变量的变化，这样的问题我们就称为 "内存可见性" 问题，造成这样的问题主要有以下两个要点：

1. JVM识别到load加载的flg的值几百万次都一样[while循环的执行速度是很快的，可能一秒几百万次]
2. load操作的花费开销是很大的，远远超过了其它操作

因此在很多次的执行之后，JVM就会觉得，反之每次结果都一样，那还有什么执行的必要吗？？因此JVM就自动地优化了代码，将load操作变成了直接使用寄存器中之前"缓存"的值，而非每次去内存中重新获取，大大降低了花费，因此就造成了即使后面修改了flg的值也无法被t2感知到的结果

5) 指令重排序问题

指令重排序实际上也是编译器优化代码的一种方式，保证逻辑不变的前提下，调整原有代码的执行顺序，提高程序的效率，自然，指令顺序都发生了改变，安全也无法保证

在描述解决这些问题之前，我们先来讲一下"锁"的概念

线程加锁

加锁的关键字

形如上图的由synchronized关键字修饰的代码块就是相当于对一个Object对象加锁，当两个线程竞争同一把锁的时候，就会引发阻塞，一个进程拿到锁之后，另外一个进程就会因为拿不到锁而陷入阻塞状态，这样就不会因为随机的变化而造成线程安全问题

我们举个例子来理解一下~~

比如你想要追求你的crush~~她有对象的时候，就相当于她加上锁了，按理来说，你就不能再追求她了，但是如果她分手了，又回归了单身状态，那就是锁解除啦，然后你就可以追求她了，你们在一起之后，就相当于你竞争到了这把锁，那其它人就不能追求你的crush啦，除非你俩又分手了，她又回归了单身状态，那么别人就可以又来竞争这把锁，此时"男朋友"这个身份就是那把锁~~~

加锁例子

我们来完善一下开头的例子，看下我们加上锁之后的结果

public class Demo21 {public static int count = 0;public static void main(String[] args) throws InterruptedException {Object locker = new Object();Thread t1 = new Thread(() -> {for(int i = 0; i < 5000; i++) {synchronized (locker) {      //共同竞争Locker这把锁count++;}}});Thread t2 = new Thread(() -> {for(int i = 0; i < 5000; i++) {synchronized (locker) {count++;}}});t1.start();t2.start();t1.join();t2.join();System.out.println(count);}
}

可以看到，此时结果就是10000了

提示

当对同一个线程多次加同一把锁的时候，是无效的，只会算一把锁，因为锁有可重入性~~

解决线程安全问题

对于问题1)

这个问题是无法解决的，这是系统的底层逻辑

对于问题2)、 3)

想要解决问题2和问题3，就是要对操作加锁，详情请参看锁篇章~~

对于问题4)、5)

想要解决这两个问题，我们要引入另一个关键字 volatile

volatile可以强制关闭JVM的代码优化机制，确保每次循环都要重新从内存中读取数据，虽然这增加了开销，但可以增加代码的准确性~~

同样的例子，我们对flg加上volatile关键字

import java.util.Scanner;public class Demo22 {public static volatile int flg = 0;        //加上volatilepublic static void main(String[] args) {Thread t1 = new Thread(() -> {while (flg == 0) {}System.out.println("t1线程结束");});Thread t2 = new Thread(() -> {System.out.println("请输入flg的值：");Scanner scan = new Scanner(System.in);flg = scan.nextInt();});t1.start();t2.start();Object locker = new Object();synchronized (locker) {}}}

运行则可以发现，t1此时就可以正常结束了~~

---

❤❤ 觉得博主写的有帮助的话，请点个赞 b(￣▽￣)d ，谢谢~~~ ❤❤

❤❤ 你的喜欢是我更新的最大动力~~~ ❤❤