目录
🍇一.线程安全问题的引入:
首先我们来看下面一段代码,我们通过两个线程同时操作一个静态成员变量count,使其一共累加10w次,看看结果:
java
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);
}
}
java
第一次执行结果:
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关键字:
解决方案:将操作共享数据的代码块锁起来
①.修饰代码块:
java
synchronized(锁对象)
{
//操作共享数据的代码
};
特点1:锁默认打开,有一个线程进去了,锁自动关闭
特点2:里面的代码全部执行完毕,线程出来,锁自动打开
特点3:锁对象,一定是唯一的
②.修饰普通方法:
java
public synchronized void doSomething(){
//操作共享数据的代码
}
其等同于:
java
public void doSomething(){
//this->当前对象的引用
synchronized(this){
//操作共享数据的代码块
}
}
③.修饰静态方法:
java
public static synchronized void doSomething(){
//操作共享数据的代码块
}
其相当于
java
public static void doSomething(){
//锁对象是当前类的字节码文件对象
synchronized(A.class){
//操作共享数据的代码块
}
}
这里我们利用synchronized关键字,解决上述线程安全问题:通过两个线程同时操作一个静态成员变量count,使其一共累加10w次
java
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修饰的代码块,相当于解锁
加锁的大致过程:
- 可重⼊:
synchronized 同步块对同⼀条线程来说是可重⼊的,不会出现⾃⼰把⾃⼰锁死的问题。
⼀个线程没有释放锁,然后⼜尝试再次加锁,按照之前对于锁的设定,第⼆次加锁的时候,就会阻塞等待.直到第⼀次的锁被释放,才能获取到第二个锁.但是释放第⼀个锁也是由该线程来完成,结果这个线程已经躺平了,啥都不想⼲了,也就⽆法进行解锁操作.这时候就会死锁.
Java 中的synchronized是可重⼊锁,因此没有上⾯的问题
java
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 不能保证原子性
java
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关键字:
java
public volatile boolean flag = true;
运行结果(从打印结果不难看出,线程一读取到了flag修改后的值,线程一顺利结束):
说到可见性,我们需要先了解一下Java内存模型,Java内存模型如下所示:
线程之间的共享变量存储在主内存中(Main Memory)中,每个线程都一个都有一个私有的本地内存(Local Memory),本地内存中存储了该线程以读/写共享变量的副本。
所以当一个线程把主内存中的共享变量读取到自己的本地内存中,然后做了更新。在还没有把共享变量刷新的主内存的时候,另外一个线程是看不到的。 引入volatile关键字,保证了内存的可见性。
由于volatile不能保证原子性,对于count++这类非原子指令的操作来说,其并不能保证线程安全:
java
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);
}
}
运行结果:
java
//第一次运行结果:
77463
//第二次运行结果:
76841
//第三次运行结果:
79114
Volatile和Synchronized的比较:
①.volatile是轻量级的synchronized,因为它不会引起上下文的切换和调度,所以volatile性能更好
②.volatile只能修饰变量,synchronized可以修饰方法,静态方法,代码块
③.volatile对任意单个变量的读/写具有原子性,但是类似于count++这种复合操作不具有原子性,而锁的互斥执行的特性可以确保对整个临界区代码执行具有原子性
④.多线程访问volatile不会发生阻塞,而synchronized会发生阻塞
⑤.volatile使变量在多线程之间的可见,synchronized保证多线程之间共享资源访问的同步性
参考资料:
结语: 写博客不仅仅是为了分享学习经历,同时这也有利于我巩固知识点,总结该知识点,由于作者水平有限,对文章有任何问题的还请指出,接受大家的批评,让我改进。同时也希望读者们不吝啬你们的点赞+收藏+关注,你们的鼓励是我创作的最大动力!