沧州网站建设价格大连seo网站推广
目录
线程安全问题引入：
线程安全原因
如何解决线程安全问题？
（1）synchronized关键字
1)sychronized关键字的特性:
2)可重⼊
synchronized使⽤⽰例
（2）volatile关键字
1）内存可见性和指令重排序
2） volatile不保证原⼦性
3）volatile总结：
线程安全问题引入：
public class demo2 {public static int count = 0;public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(()->{for (int i = 0; i < 10000; i++) {count++;}});Thread t2 = new Thread(()->{for (int i = 0; i < 10000; i++) {count++;}});t1.start();t2.start();t1.join();t2.join();System.out.println(count);}
}
执行结果：
count=14423执行结果：
count=10223执行结果：
count=12123由此可见，我们正常情况下想得到的结果为20000，而现在的结果却不尽人意 很明显在此情况下代码出现了bug。
因为多个线程并发执行，引起的bug,这样的bug称为“线程安全问题”或者叫做“线程不安全”
线程安全原因
问题分析：
（1）线程在操作系统中是随机调度，抢占式执行的【根本原因】
（2）当前代码中多个线程修改一个变量
多个线程修改同⼀个变量
上⾯的线程不安全的代码中,涉及到多个线程针对 count 变量进⾏修改.
此时这个 count 是⼀个多个线程都能访问到的"共享数据
（3）修改操作，不是“原子”的
不保证原⼦性会给多线程带来什么问题
如果⼀个线程正在对⼀个变量操作，中途其他线程插⼊进来了，如果这个操作被打断了，结果就可能是错误的。
count++操作实际上分成三步：
1）load 从内存中读取数据到cpu的寄存器
2）add 把寄存器中的值+1
3）save 把寄存器的值写回内存中
而由于线程调度是随机调度，抢占式执行的，这就导致了两个线程的count++操作三步骤是会被打乱顺序的。
还有其他原因稍后介绍...
如何解决线程安全问题？
（1）synchronized关键字
1)sychronized关键字的特性:
synchronized会起到互斥效果,某个线程执⾏到某个对象的synchronized中时,其他线程如果也执⾏到同⼀个对象synchronized就会阻塞等待
• 进⼊synchronized修饰的代码块,相当于加锁
• 退出synchronized修饰的代码块,相当于解锁
public class demo2 {public static int count = 0;public static void main(String[] args) throws InterruptedException {Object locker = new Object();Thread t1 = new Thread(()->{synchronized (locker) {for (int i = 0; i < 10000; i++) {count++;}}});Thread t2 = new Thread(()->{synchronized (locker) {for (int i = 0; i < 10000; i++) {count++;}}});t1.start();t2.start();t1.join();t2.join();System.out.println(count);}
}
通过对count++的整体加锁，使得每一次的count++都是一个整体，解决了此处的线程安全问题。
加锁的过程：
可以粗略理解成,每个对象在内存中存储的时候,都存有⼀块内存表⽰当前的"锁定"状态(类似于厕所
的"有⼈/⽆⼈").
如果当前是"⽆⼈"状态,那么就可以使⽤,使⽤时需要设为"有⼈"状态.
如果当前是"有⼈"状态,那么其他⼈⽆法使⽤,只能排队
- 上⼀个线程解锁之后,下⼀个线程并不是⽴即就能获取到锁.⽽是要靠操作系统来"唤醒".这也就是操作系统线程调度的⼀部分⼯作.
- 假设有ABC三个线程,线程A先获取到锁,然后B尝试获取锁,然后C再尝试获取锁,此时B和C都在阻塞队列中排队等待.但是当A释放锁之后,虽然B⽐C先来的,但是B不⼀定就能获取到锁,⽽是和C重新竞争,并不遵守先来后到的规则.
2)可重⼊
synchronized同步块对同⼀条线程来说是可重⼊的，不会出现⾃⼰把⾃⼰锁死的问题
按照之前对于锁的设定,第⼆次加锁的时候,就会阻塞等待.直到第⼀次的锁被释放,才能获取到第⼆个锁.但是释放第⼀个锁也是由该线程来完成,结果这个线程已经躺平了,啥都不想⼲了,也就⽆法进⾏解锁操作.这时候就会死锁
for (int i = 0; i < 50000; i++) {
synchronized (locker) {
synchronized (locker) {count++;}}
}public class demo2 {public static int count = 0;public static void main(String[] args) throws InterruptedException {Object locker = new Object();Thread t1 = new Thread(()->{synchronized (locker) {synchronized (locker) {for (int i = 0; i < 10000; i++) {count++;}}}});Thread t2 = new Thread(()->{synchronized (locker) {synchronized (locker) {for (int i = 0; i < 10000; i++) {count++;}}}});t1.start();t2.start();t1.join();t2.join();System.out.println("count="+count);}
}
count=20000synchronized使⽤⽰例
1)修饰代码块:明确指定锁哪个对象.
锁任意对象
public class SynchronizedDemo {private Object locker = new Object();public void method() {synchronized (locker) {}}
}锁当前对象
public class SynchronizedDemo {public void method() {synchronized (this) {}}
}2)直接修饰普通⽅法:锁的SynchronizedDemo对象
public class SynchronizedDemo {public synchronized void methond() {}
}3)修饰静态⽅法:锁的SynchronizedDemo类的对象
public class SynchronizedDemo {public synchronized static void method() {}
}我们重点要理解，synchronized锁的是什么.两个线程竞争同⼀把锁,才会产⽣阻塞等待.
两个线程分别尝试获取两把不同的锁,不会产⽣竞争.
（2）volatile关键字
1）内存可见性和指令重排序
还有一直情况就是“内存可见性”和“指令重排序”引发的线程安全
下列代码原本用意是：当用户输入非0数字时，结束线程t1。
import java.util.Scanner;
public class demo3 {private static int flag = 0;public static void main(String[] args) {Thread t1 = new Thread(() -> {while (flag == 0) {// 循环体里, 啥都不写会触发内存可见性问题}System.out.println("t1 线程结束!");});Thread t2 = new Thread(() -> {System.out.println("请输入 flag 的值: ");Scanner scanner = new Scanner(System.in);flag = scanner.nextInt();});t1.start();t2.start();}
}
在这个代码中
• 创建两个线程t1和t2
• t1中包含⼀个循环,这个循环以flag==0为循环条件.
• t2中从键盘读⼊⼀个整数,并把这个整数赋值给flag.可结果是：
t1读的是⾃⼰⼯作内存中的内容.
当t2对flag?变量进⾏修改,此时t1感知不到flag的变化.
//如果给flag加上volatile
private static volatile int flag = 0;import java.util.Scanner;
public class demo3 {private static volatile int flag = 0;public static void main(String[] args) {Thread t1 = new Thread(() -> {while (flag == 0) {// 循环体里, 啥都不写会触发内存可见性问题}System.out.println("t1 线程结束!");});Thread t2 = new Thread(() -> {System.out.println("请输入 flag 的值: ");Scanner scanner = new Scanner(System.in);flag = scanner.nextInt();});t1.start();t2.start();}
}
2）volatile不保证原⼦性
public class demo3 {private 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.join();t2.join();System.out.println(count);}
}count=68741此时可以看到,最终count的值仍然⽆法保证是100000.
3）volatile总结：
1. 内存可见性
在多线程环境下，每个线程都有自己的本地内存（例如 CPU 的寄存器和缓存），当线程修改一个变量时，修改的内容可能只会被保存在线程的本地内存中，而不是立即刷新到主内存中。这可能导致其他线程读取该变量时，看到的是过时的数据。
volatile关键字确保了：
当一个线程修改
volatile变量时，修改后的值会立即刷新到主内存。其他线程读取这个
volatile变量时，会直接从主内存中读取最新的值，而不是从自己的本地缓存中读取。2. 禁止指令重排
volatile变量还具有防止指令重排的效果。指令重排是现代处理器为了提高性能，在程序执行时调整指令执行顺序的行为。它可能导致程序出现一些非预期的结果，特别是在多线程编程中。
volatile关键字保证了变量的读写顺序不会被重排，因此它能确保代码在多个线程中的执行顺序符合预期。3. 不具备原子性
volatile关键字虽然可以确保内存可见性和禁止指令重排，但并不具备原子性。也就是说，如果对一个volatile变量进行复合操作（例如：i++），它并不能保证操作的原子性。因为复合操作通常涉及多个步骤，如读取值、修改值、写回主内存，这些步骤不能保证在多线程环境下不会被打断。因此，volatile只能用于简单的赋值操作。
synchronized关键字vs volatile关键字
| 特性 | synchronized | volatile |
|---|---|---|
| 作用 | 提供互斥性和可见性，确保一个线程执行某个方法时，其他线程不能访问被保护的代码块。 | 仅保证变量的可见性，确保一个线程对该变量的修改能够立刻反映到其他线程。 |
| 性能开销 | 存在较高的性能开销，因为它涉及到线程的加锁和解锁操作。 | 相对较低的性能开销，只在访问volatile变量时有较小的性能影响。 |
| 原子性 | 提供原子性，确保多线程在同一时刻只会有一个线程访问同步方法或同步代码块。 | 不保证原子性，仅仅保证可见性。例如 volatile 不能保证 ++ 操作的原子性。 |
| 使用场景 | 适用于需要保证原子性和互斥访问的场景，如多个线程同时修改共享变量。 | 适用于多线程间共享变量的简单读写场景，特别是标志位和开关。 |
总结
synchronized：适用于需要保证线程安全和原子性操作的场景，通过加锁来保证一个线程在执行某个代码块时，其他线程无法同时访问这些代码，从而避免并发问题。volatile：适用于保证多线程之间共享变量的可见性，尤其是用于标志位等简单的读写操作，但它不保证操作的原子性，因此不适用于需要进行复合操作的情况。在实际应用中，如果一个变量的读写操作不涉及复杂的计算和操作，且只需要保证它的可见性，可以考虑使用
volatile。如果需要对共享资源进行复杂操作（如累加、修改多个共享变量等），则需要使用synchronized来保证互斥性和原子性。
结语： 写博客不仅仅是为了分享学习经历，同时这也有利于我巩固知识点，总结该知识点，由于作者水平有限，对文章有任何问题的还请指出，接受大家的批评，让我改进。同时也希望读者们不吝啬你们的点赞+收藏+关注，你们的鼓励是我创作的最大动力！