java线程安全问题的原因与大致解决思路

最新推荐文章于 2024-05-24 11:06:19 发布

甘枳

最新推荐文章于 2024-05-24 11:06:19 发布

阅读量385

点赞数 3

文章标签： jvm

本文链接：https://blog.csdn.net/qq_55546526/article/details/126906902

版权

在我们编写多线程程序的时候,经常会因为线程安全问题导致出现各种各样的bug,这里我们总结一些线程安全的原因和大致的解决思路

线程安全的问题

1.操作系统的抢占执行

这个问题时我们编写多线程代码时,出现线程安全问题的罪魁祸首,当然,这个问题也是操作系统方面的,我们并没有办法去解决这个问题

2.多个线程修改同一个变量

在多线程中,我们多个线程修改同一个变量的时候,也很容易触发线程安全问题,我们可以适当调整代码来解决这个问题,但是并不是每次都可以调节代码的,所以这个也不是重点

3.操作不是原子性的

我们改变不了上面的两个问题,但是我们可以改变这个问题,我们可以吧操作变成原子操作,通过加锁操作来实现,这样我们就可以一定程度上保护线程安全

4.内存可见性

所谓的内存可见性,就是指一个线程修改了一个公共的值,另一个线程也能看到

5.指令重排序

指令重排序就是指,在单线程情况下,很多代码的执行顺序会影响执行速度,写编译器的大佬就把这代码进行重排序优化

线程安全的解决方法

前面的两个我们没有办法改变,我们从第三个开始讲解决思路

3.操作不是原子性的

在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 < 5000; i++) {
                count++;
            }
        });
        Thread t2 = new Thread(() ->{
            for (int i = 0; i < 5000; i++) {
                count++;
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(count);
    }
}

这段代码中我们使用两个线程对count进行累加操作,但是得到的结果好像并不是我们想要的,这就出现了线程安全问题,因为++操作其实有三个子操作,分别是load,add,save,当着三个子操作不是原子操作的时候,可能就会出现两个线程执行++只进行了一次自增的情况,所以导致结果不是我们想要的,

那我们应该怎么解决呢?

加锁!!!

我们可以通过加锁操作,让操作变成原子性的

经过改进,我们给两个线程加上锁,使其成为原子操作(这里的代码编写并不是很好,只是为了表达意思)

public class Main {
    public static int count = 0;
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() ->{
            synchronized (Main.class){
                for (int i = 0; i < 5000; i++) {
                    count++;
                }
            }
        });
        Thread t2 = new Thread(() ->{
            synchronized (Main.class){
                for (int i = 0; i < 5000; i++) {
                    count++;
                }
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(count);
    }
}

可以看到我们的结果就得到了10000,也就解决了这种类型的问题

4.内存可见性

直接看这个问题先

class A extends Thread {
    public int i = 0;
    public void run() {
        while(i == 0){

        }
    }
}


public class Main {
    public static void main(String[] args) throws InterruptedException {
        A t1 = new A();
        Scanner sc = new Scanner(System.in);
        t1.start();

        t1.i = sc.nextInt();
        t1.join();
    }
}

这里我们执行的结果是

可以看到当我们输入5之后,他并没有结束线程,这是为什么呢?

因为我们的编译器进行了自动的优化,让我们的while循环中的判断只执行一次,如果在单线程的情况下,这样当然是没问题的了,但是在多线程的情况下,就会出问题,闹我们如何解决呢?

前面提到了volatile关键字,我们对代码进行修改

class A extends Thread {
    public volatile int i = 0;
    public void run() {
        while(i == 0){

        }
    }
}


public class Main {
    public static void main(String[] args) throws InterruptedException {
        A t1 = new A();
        Scanner sc = new Scanner(System.in);
        t1.start();

        t1.i = sc.nextInt();
        t1.join();
    }
}