目录

🍇一.线程安全问题的引入：

🍒二.线程安全问题产生的原因：

🍌三.如何解决线程安全问题：

🎉1.synchronized关键字:

🦉sychronized关键字的特性:

✨2.volatile关键字:

🍇一.线程安全问题的引入：

首先我们来看下面一段代码，我们通过两个线程同时操作一个静态成员变量count，使其一共累加10w次，看看结果：

<code>public class Main {

public 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,t2线程结束，统计此时count的累加结果

t1.join();

t2.join();

System.out.println(count);

}

}

第一次执行结果：

59355

第二次执行结果：

54362

第三次执行结果：

53976

这是我们发现，三次累加count的结果都不一样，很明显，这里出现了bug!

因为多个线程并发执行，引起的bug,这样的bug称为“线程安全问题”或者叫做“线程不安全”

🍒二.线程安全问题产生的原因：

那么这个问题是怎样产生的呢？这里，我们引出线程安全问题产生的原因：

线程在操作系统中是随机调度，抢占式执行的【根本原因】

程序中的多个线程是并发执行的，某个线程若想被执行必须要得到CPU的使用权，Java虚拟机会按照特定的机制为程序中的每个线程分配CPU的使用权，这种机制被称为线程的调度。

两种线程调度的模式：

①.分时调度模式：让所有的线程轮流获得CPU的使用权，并且平均分配给每个线程占用CPU的时间段

②.抢占式调度模式：让就绪队列中优先级高的线程优先占用CPU，而对于优先级相同的线程，随机选择一个线程使其占用CPU，当它失去了CPU的使用权后，在随机选择其他线程使其占用CPU。

多个线程，由于是并发执行的，此时如果同时修改一个共享数据的代码块或则变量，会导致线程安全问题

修改操作，不是“原子”的

这里的原子性与MySQL事务中的原子性是一个意思，对于一组操作，这组操作是不可分割的最小单元，程序运行时要么同时成功，要么同时失败，不存在程序运行一般就结束的情况，这个操作要求一气呵成。而在CPU的视角，一条指令就是CPU上不可分割的最小单元，CPU在进行调度切换线程的时候，势必会确保执行完一条完整的指令，这个过程包含取指令，解析指令和执行指令。而上述的count++这个操作，就不是原子的，其在CPU看来有三个指令：

①.把内存中的数据，读取到CPU寄存器中 (load操作)

②.把CPU寄存器里的值+1 （add操作）

③.把寄存器里的值，写回到内存中 （save操作）

此时我们在对上述操作进行分析t1,t2两个线程：

内存可见性问题：

可见性定义：指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。

在多线程环境下，一个线程对共享变量的操作对其他线程是不可见的。Java提供了volatile关键字来保证可见性，当一个变量被volatile修饰后，表示着本地内存无效，当一个线程修改共享变量后他会立即被更新到主存中，其他线程读取共享变量的时候，会直接从主存中读取，从而实现了可见性.

指令重排序:

在执行程序时，为了提高性能，编译器和处理器常常会对指令做重排序。重排序分为如下三种：

1属于编译器重排序，2和3属于处理器重排序。这些重排序可能会导致多线程程序出现内存可见性问题。

JVM翻译字节码指令，CPU执行机器码指令，都可能发生重排序来优化执行效率

比如有这样三步操作：(1) 去前台取U盘 (2) 去教室写作业 (3) 去前台取快递 JVM会对指令优化，也就是重排序，新的顺序为(1)(3)(2),这样来提高效率

导致线程安全问题的小结：

线程是抢占式的执行，线程间的调度充满了随机性多个线程对同一个变量进行修改操作对变量的操作不是原子性的内存可见性导致的线程安全指令重排序也会影响线程安全

🍌三.如何解决线程安全问题：

🎉1.synchronized关键字:

解决方案：将操作共享数据的代码块锁起来

①.修饰代码块：

<code>synchronized(锁对象)

{

//操作共享数据的代码

}；

特点1：锁默认打开，有一个线程进去了，锁自动关闭

特点2：里面的代码全部执行完毕，线程出来，锁自动打开

特点3:锁对象，一定是唯一的

②.修饰普通方法：

public synchronized void doSomething(){

//操作共享数据的代码

}

其等同于：

public void doSomething(){

//this->当前对象的引用

synchronized(this){

//操作共享数据的代码块

}

}

③.修饰静态方法：

public static synchronized void doSomething(){

//操作共享数据的代码块

}

其相当于

public static void doSomething(){

//锁对象是当前类的字节码文件对象

synchronized(A.class){

//操作共享数据的代码块

}

}

这里我们利用synchronized关键字，解决上述线程安全问题：通过两个线程同时操作一个静态成员变量count，使其一共累加10w次

public class Main {

public static int count = 0;

public static void main(String[] args) throws InterruptedException {

Thread t1 = new Thread(()->{

for(int i = 0;i < 50000;i++){

//利用锁将操作共享数据的代码块锁起来，每次只允许一个线程进入进行操作

//从而解决了线程安全问题

synchronized (Main.class){

count++;

}

}

});

Thread t2 = new Thread(()->{

for(int i = 0;i < 50000;i++){

//利用锁将操作共享数据的代码块锁起来，每次只允许一个线程进入进行操作

synchronized(Main.class){

count++;

}

}

});

t1.start();

t2.start();

//让主线程等待t1,t2线程结束，统计此时count的累加结果

t1.join();

t2.join();

System.out.println(count);

}

}

运行结果（此时我们无论运行多少次，count的计算结果都是10w）：

sychronized关键字的作用：

①.sychronized是基于对象头加锁的，特别注意：不是对代码加锁，所说的加锁操作就是给这个对象的对象头里设置了一个标志位，一个对象在同一时间只能有一个线程获取到该对象的锁

②.sychronized保证了原子性，可见性，有序性（这里的有序不是指指令重排序，而是具有相同锁的代码块按照获取锁的顺序执行）

🦉sychronized关键字的特性:

1).互斥：

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

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

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

加锁的大致过程：

2) 可重⼊：

synchronized 同步块对同⼀条线程来说是可重⼊的，不会出现⾃⼰把⾃⼰锁死的问题。

⼀个线程没有释放锁,然后⼜尝试再次加锁，按照之前对于锁的设定,第⼆次加锁的时候,就会阻塞等待.直到第⼀次的锁被释放,才能获取到第二个锁.但是释放第⼀个锁也是由该线程来完成,结果这个线程已经躺平了,啥都不想⼲了,也就⽆法进行解锁操作.这时候就会死锁.

Java 中的synchronized是可重⼊锁,因此没有上⾯的问题

<code>public class Main2 {

public static int count = 0;

public static void main(String[] args) throws InterruptedException {

Thread t1 = new Thread(()->{

for(int i = 0;i < 50000;i++){

//利用锁将操作共享数据的代码块锁起来，每次只允许一个线程进入进行操作

//从而解决了线程安全问题

synchronized (Main2.class){

synchronized (Main2.class){

count++;

}

}

}

});

Thread t2 = new Thread(()->{

for(int i = 0;i < 50000;i++){

//利用锁将操作共享数据的代码块锁起来，每次只允许一个线程进入进行操作

synchronized (Main2.class){

synchronized (Main2.class){

count++;

}

}

}

});

t1.start();

t2.start();

//让主线程等待t1,t2线程结束，统计此时count的累加结果

t1.join();

t2.join();

System.out.println(count);

}

}

运行结果：

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

• 如果某个线程加锁的时候,发现锁已经被⼈占⽤,但是恰好占⽤的正是⾃⼰,那么仍然可以继续获取到锁,并让计数器⾃增.

• 解锁的时候计数器递减为0的时候,才真正释放锁.(才能被别的线程获取到)

✨2.volatile关键字:

volatile关键字的作用主要有如下两个：(volatile是用来修饰变量的，它的作用是保证可见性，有序性)

保证内存可见性：基于屏障指令实现，即当一个线程修改一个共享变量时，另外一个线程能读到这个修改的值。

保证有序性：禁止指令重排序。编译时 JVM 编译器遵循内存屏障的约束，运行时靠屏障指令组织指令顺序。

注意：volatile 不能保证原子性

<code>public class Main {

public boolean flag = true;

//改变flag的值

public void changeFlag(){

this.flag = false;

}

public static void main(String[] args) {

Main test = new Main();

Thread t1 = new Thread(()->{

while(test.flag){

}

System.out.println("线程一结束~~~");

});

Thread t2 = new Thread(()->{

try {

Thread.sleep(1000);

test.changeFlag();

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("线程二结束");

});

t1.start();

t2.start();

}

}

运行结果：

当我们给变量flag加上volatile关键字:

<code> public volatile boolean flag = true;

运行结果（从打印结果不难看出，线程一读取到了flag修改后的值，线程一顺利结束）：

说到可见性，我们需要先了解一下Java内存模型，Java内存模型如下所示：

线程之间的共享变量存储在主内存中（Main Memory）中，每个线程都一个都有一个私有的本地内存（Local Memory），本地内存中存储了该线程以读/写共享变量的副本。

所以当一个线程把主内存中的共享变量读取到自己的本地内存中，然后做了更新。在还没有把共享变量刷新的主内存的时候，另外一个线程是看不到的。 引入volatile关键字，保证了内存的可见性。

由于volatile不能保证原子性，对于count++这类非原子指令的操作来说，其并不能保证线程安全：

<code>public class Main {

public static volatile 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,t2线程结束，统计此时count的累加结果

t1.join();

t2.join();

System.out.println(count);

}

}

运行结果：

//第一次运行结果：

77463

//第二次运行结果：

76841

//第三次运行结果：

79114

Volatile和Synchronized的比较：

①.volatile是轻量级的synchronized,因为它不会引起上下文的切换和调度，所以volatile性能更好

②.volatile只能修饰变量，synchronized可以修饰方法，静态方法，代码块

③.volatile对任意单个变量的读/写具有原子性，但是类似于count++这种复合操作不具有原子性，而锁的互斥执行的特性可以确保对整个临界区代码执行具有原子性

④.多线程访问volatile不会发生阻塞，而synchronized会发生阻塞

⑤.volatile使变量在多线程之间的可见，synchronized保证多线程之间共享资源访问的同步性

参考资料：

Volatile关键字的作用-CSDN博客

线程安全问题（面试常考）-CSDN博客

结语： 写博客不仅仅是为了分享学习经历，同时这也有利于我巩固知识点，总结该知识点，由于作者水平有限，对文章有任何问题的还请指出，接受大家的批评，让我改进。同时也希望读者们不吝啬你们的点赞+收藏+关注，你们的鼓励是我创作的最大动力！