目录
1. 线程不安全问题
2. 线程不安全的原因
3. 解决线程不安全问题
1. 线程不安全问题
线程安全问题是多线程编程必须考虑的重要问题,也因为其难以理解与处理,故而程序员也尝试发明更多的编程模型来处理并发编程,如多进程、多线程、actor、csp等等;
我们知道,操作系统调度线程是抢占式执行,这样的随机性可能会导致程序执行出现一些bug,如果由于这样的调度的随机性使得代码出现了bug,则认为代码是不安全的,如果没有引入bug,则认为代码是安全的;
线程不安全的典型案例:使用两个线程对同一个整型变量进行自增操作,每个线程自增五万次:
class Counter{
//保存两个线程要自增的变量
public int count = 0;
public void increase(){
count++;
}
}
public class Demo1 {
private static Counter counter = new Counter();
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(()->{
for(int i=0;i<50000;i++){
counter.increase();
}
});
Thread t2 = new Thread(()->{
for(int i=0;i<50000;i++){
counter.increase();
}
});
t1.start();
t2.start();
//在main线程中打印两个线程自增结束后得到的count结果
//t1、t2执行结束后再打印count结果
t1.join();
t2.join();
System.out.println(counter.count);
}
}
运行三次,输出结果与预期并不相符且多次运行多次不同:
注:1.t1.join()与t2.join()谁先谁后均可:
线程是随机调度的,t1、t2线程的结束前后是未知的,
如果t1先结束,则先令main线程等待t1结束,待t1结束后再令main线程等待t2结束;
如果t2先结束,仍先令main等待t1结束,t2结束了t1还未结束,main线程仍然在等待t1结束,等t1结束后,t2已经结束了,则此时t2.jion()立即返回;
2.站在CPU角度来看,count++实际上是3个CPU指令:
第一步:将内存中count值加载到CPU寄存器中;(load)
第二步:寄存器中的值将其+1;(add)
第三步:把寄存器中的值写回到内存的count中;(save)
由于抢占式执行,两个线程同时执行这三个指令的时候顺序上充满了随机性,只有当两个线程的三条指令串型执行的时候才会符合预期,只要三条指令出现交错,就会出现错误,如:
2. 线程不安全的原因
(1)根本原因:线程是抢占式执行,线程间的调度充满随机性;
(2)修改共享数据:多个线程对同一个变量进行修改操作,才会导致线程不安全问题;
当多个线程分别对不同的多个变量进行操作,或是多个线程对同一个变量进行读操作,都不会导致线程不安全问题;
(3)操作的原子性问题:针对变量的操作不是原子性的,就会导致线程不安全问题,如上文示例中,自增操作其实是3条指令;
当操作是原子性的,如读取变量的值就只对应一条机器指令,就不会导致线程不安全问题;
(4)内存可见性问题:java编译器的优化操作使得在某些情况下线程之间出现信息不同步问题:
如线程t1一直在高速循环进行读操作,线程t2不定时进行修改操作,此时由于t1的高速访问可能无果,就会停止将数据从内存中读至寄存器中再进行读取,而直接从寄存器中读取,此时若t2线程进行修改操作,就会由于内存可见性问题而使两个线程信息不同步,出现安全问题,示例代码如下:
import java.util.Scanner;
public class Demo2 {
private static int isQuit = 0;
public static void main(String[] args) {
Thread t = new Thread(()->{
while(0 == isQuit){
}
System.out.println("Thread t has finished.");
});
t.start();
Scanner scanner = new Scanner(System.in);
System.out.println("Please input the value of isQuit: ");
isQuit = scanner.nextInt();
System.out.println("Thread main has finished.");
}
}
输出结果为:
并未输出"Thread t has finished."说明t线程并未结束;
(5)指令重排序问题:指令重排序也是编译器优化的一种操作,编译器在某些情况下可能调整代码的先后顺序来提高程序的效率,单线程通常不会出现问题,但在多线程代码中,可能就会误判导致线程安全问题;
3. 解决线程不安全问题
对应上文的线程不安全问题原因,思考解决线程不安全问题的方法:
(1)线程调度的随机性问题:无法从代码层面进行改进的;
(2)多线程修改同一变量问题:部分情况下可调整代码结构,使不同线程操作不同变量;
(3)变量操作的原子性问题:加锁操作将多个操作打包为一个原子性操作;
(4)内存可见性问题:
① 使用synchronized关键字可以保证内存可见性,被synchronied修饰的代码块,相当于手动禁止了编译器的优化;
② 使用volatile关键字可以保证内存可见性,禁止编译器做出上述优化:
import java.util.Scanner;
public class Demo2 {
private static volatile int isQuit = 0;
public static void main(String[] args) {
Thread t = new Thread(()->{
while(0 == isQuit){
}
System.out.println("Thread t has finished.");
});
t.start();
Scanner scanner = new Scanner(System.in);
System.out.println("Please input the value of isQuit: ");
isQuit = scanner.nextInt();
System.out.println("Thread main has finished.");
}
}
此时输出结果为:
(5)指令重排序问题:synchronized关键字可以禁止指令重排序;
注:synchronized解决多线程修改同一变量问题代码示例:
使用锁后,就将线程间乱序的并发变成了一个串型操作,并发性降低但会更安全;
虽然效率有所降低但相较于单线程程序,还是能分担步骤压力,效率还是较高的;
java中加锁的方式有很多种,最常使用的是synchronized关键字:
class Counter{
public int count=0;
synchronized public void increase(){
count++;
}
}
public class Demo1 {
private static Counter counter = new Counter();
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(()->{
for(int i=0;i<50000;i++){
counter.increase();
}
});
Thread t2 = new Thread(()->{
for(int i=0;i<50000;i++){
counter.increase();
}
});
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(counter.count);
}
}
输出结果为:
注:(1)在increase()方法前加上synchronized修饰,此时进入方法就会自动加锁,离开方法就会自动解锁;
(2)当给一个线程加锁成功时,其他线程尝试加锁就会触发阻塞等待,此时对应的线程就处于clocked状态;
(3)阻塞状态会一直持续到占用锁的线程解锁为止,时间轴缩略图如下:
(3)synchronized可以保证操作的原子性,保证内存可见性,还可以禁止指令重排序;