线程不安全的原因2

多线程系列文章目录

---

💥 💥 💥如果你觉得我的文章有帮助到你，还请【关注➕点赞➕收藏】，得到你们支持就是我最大的动力!!!
💥 💥 💥

⚡版权声明：本文由【马上回来了】原创、在CSDN首发、需要转载请联系博主。
版权声明：本文为CSDN博主「马上回来了」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。

🚀🚀🚀 新的知识开始喽🚀🚀🚀

---

0.常见的线程不安全的原因

上篇文章线程不安全的原因1已经详细的讲解了线程不安全的原因之一就是没有上锁,这篇文章继续讲解剩下的常见的导致多线程不安全的原因:
1.操作系统的随机抢占式调度
2.多个线程同时修改同一个变量(这个如果是业务逻辑的需要,就无法避免,只能根据剩下的几个原因来保证多线程修改同个变量是线程安全的)
3.操作语句不是原子的
4.编译器优化带来的内存可见性问题
5.编译器优化带来的指令重排序的问题

2.操作系统的随机抢占式调度

这是多线程不安全的万恶之源,操作系统对于多个线程的调度顺序是随机的,没有固定的顺序,当程序运行起来之后每个线程都去抢占式去占用cpu,而线程的执行顺序在很多业务逻辑里是非常重要的,因此为了缓解这个问题,java的标准库里提供了wait和notify两个方法.
wait是Object类里的方法,所以任何对象都能调用这个方法,wait方法的作用是让调用这个方法的线程进入阻塞状态.

常用的是wait不带参数的方法和带有一个时间参数的方法:

notify是和wait配套使用的,notify能将线程里由于wait导致线程阻塞的线程给唤醒:

wait和notify的使用要注意:

看代码:

public class demo1 {
    public static void main(String[] args) {
        Object object = new Object();
        Thread t = new Thread(){
            @Override
            public void run() {
                synchronized (object){
                    System.out.println("wait前的业务逻辑");
                    try {
                        object.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("wait后的逻辑");
                }

            }
        };
        Thread t1 = new Thread(){
            @Override
            public void run() {
                synchronized (object){
                    System.out.println("notify之前的逻辑");
                    object.notify();
                    System.out.println("notify之后的逻辑");
                }

            }
        };
        t.start();
        t1.start();
    }
}

运行结果:

wait和notify的更多使用案例请看我的文章多线程案例2:阻塞队列的模拟实现,

3.操作语句不是原子的

就是要加锁,上篇文章讲的非常详细线程不安全的原因1:synchronized

4.编译器优化所带来的内存可见性问题

先看这个代码:

class Count{
     public int count = 0;
}
public class demo1 {

    public static void main(String[] args) {
        Count count = new Count();
        Thread t = new Thread(){
            @Override
            public void run() {
                while (count.count == 0){

                }
                System.out.println("t线程结束");
            }
        };
        t.start();
        Thread t1 = new Thread(){
            @Override
            public void run() {
                System.out.println("请输入数字:");
                Scanner scanner = new Scanner(System.in);
                count.count = scanner.nextInt();
            }
        };

        t1.start();
    }

}

运行结果:

因此要解决这个潜在的问题,可以使用关键字volatile,用volatile修饰count,就可以阻止编译器只访问一次内存,保证load每次都是从内存上读取数据:

class Count{
     volatile public int count = 0;
}
public class demo1 {

    public static void main(String[] args) {
        Count count = new Count();
        Thread t = new Thread(){
            @Override
            public void run() {
                while (count.count == 0){

                }
                System.out.println("t线程结束");
            }
        };
        t.start();
        Thread t1 = new Thread(){
            @Override
            public void run() {
                System.out.println("请输入数字:");
                Scanner scanner = new Scanner(System.in);
                count.count = scanner.nextInt();
            }
        };

        t1.start();
    }

}

运行结果:

如果让while不转那么快,编译器就不会触发优化:

class Count{
      public int count = 0;
}
public class demo1 {

    public static void main(String[] args) {
        Count count = new Count();
        Thread t = new Thread(){
            @Override
            public void run() {
                while (count.count == 0){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("t线程结束");
            }
        };
        t.start();
        Thread t1 = new Thread(){
            @Override
            public void run() {
                System.out.println("请输入数字:");
                Scanner scanner = new Scanner(System.in);
                count.count = scanner.nextInt();
            }
        };

        t1.start();
    }

}

运行结果:

或者可以让其他线程快速修改变量,使while循环里第一次load就能及时获取到已经更新好的count的数值:

 class Count0{
     public int count = 0;
}
public class demo2 {

    public static void main(String[] args) {
        Count0 count = new Count0();
        Thread t = new Thread() {
            @Override
            public void run() {
                while (count.count == 0) {

                }
                System.out.println("t线程结束");
            }
        };
        t.start();
        Thread t1 = new Thread(){
            @Override
            public void run() {
            count.count = 1;
            }
        };
        t1.start();
    }

}

内存可见性问题对应JMM模型(Java Memory Model).
volatile防止编译器进行内存可见性的优化,避免直接从CPU寄存器上读取数据,保证每次都是从内存上读取数据.
站在JMM模型来看待volatile:
正常的程序运行时,会把主内存(内存)的数据先加载到工作内存(CPU的寄存器/缓存区)中,在进行计算处理.
编译器优化可能导致不是每次都读取主内存,而是直接读取工作内存中的缓存数据,因此就可能到导致内存可见性的问题,volatile的效果就是保证每次都是从主内存里读取数据.

5.编译器优化带来的指令重排序的问题

这在我的文章多线程案例1:单例模式的第四点里有详细讲解:

---

---

🌏🌏🌏今天的你看懂这里又学到了很多东西吧🌏🌏🌏

🌔 🌔 🌔下次见喽🌔 🌔 🌔