阅读量:0
目录
🍇一.线程安全问题的引入：
首先我们来看下面一段代码，我们通过两个线程同时操作一个静态成员变量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++){ 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关键字:
解决方案：将操作共享数据的代码块锁起来
①.修饰代码块：
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是可重⼊锁,因此没有上⾯的问题
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 不能保证原子性
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关键字:
public volatile boolean flag = true; 运行结果（从打印结果不难看出，线程一读取到了flag修改后的值，线程一顺利结束）：
说到可见性，我们需要先了解一下Java内存模型，Java内存模型如下所示：
线程之间的共享变量存储在主内存中（Main Memory）中，每个线程都一个都有一个私有的本地内存（Local Memory），本地内存中存储了该线程以读/写共享变量的副本。
所以当一个线程把主内存中的共享变量读取到自己的本地内存中，然后做了更新。在还没有把共享变量刷新的主内存的时候，另外一个线程是看不到的。 引入volatile关键字，保证了内存的可见性。
由于volatile不能保证原子性，对于count++这类非原子指令的操作来说，其并不能保证线程安全：
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保证多线程之间共享资源访问的同步性
参考资料：
结语： 写博客不仅仅是为了分享学习经历，同时这也有利于我巩固知识点，总结该知识点，由于作者水平有限，对文章有任何问题的还请指出，接受大家的批评，让我改进。同时也希望读者们不吝啬你们的点赞+收藏+关注，你们的鼓励是我创作的最大动力！
