多线程带来的风险——线程安全_一个软件需要多线程,但是没有开启多线程,会怎么样-优快云博客

本文链接：https://blog.youkuaiyun.com/m0_66488562/article/details/132794281

1、线程风险的来源

多线程带来的风险主要来源：多线程的抢占式执行、随机调度，带来的随机性

假设没有使用多线程，使用的是单线程，那么此时的代码执行顺序就是固定的（只有一条线路），那么程序的结果也就是固定的

假设使用的是多线程，此时抢占式执行下，代码的执行顺序，就会出现很多的变数，代码执行顺序的可能性就变成了多种情况，只要有一种情况下，代码结果不正确，就能视为有bug，线程不安全

2、线程不安全代码

public class Demo {
    public static void main(String[] args) {
        CountAdd countAdd = new CountAdd();
        Thread thread1 = new Thread(()->{
            for (int i = 1; i <= 50000; i++) {
                countAdd.add();
            }
        });
        Thread thread2 = new Thread(()->{
            for (int i = 1; i <= 50000; i++) {
                countAdd.add();
            }
        });
        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(countAdd.count);
    }
}

class CountAdd {
    public int count;
    public void add() {
        count++;
    }
}

代码多次运行结果如下：

两个线程各自增5w次，一共自增了10w次，我们预期的结果应该是10w，但是执行结果并不是10w，而且每次的运行结果仿佛都不太一样，那么这个就称为bug

那接下来我们就一起来分析分析这个代码的bug究竟出现在什么地方呢？

首先我们从 countAdd 方法中的 count++ 看起

count++ 操作本质上其实要分为三步，分别为：

先把内存中的值，读取到CPU的寄存器中，也就是 load 操作
把 CPU 寄存器里的数值进行 +1 运行，也就是 add 操作
把得到的结果写回到内存中，也就是 save 操作

这三个操作，其实就是CPU上执行的指令

如果两个线程不是并发执行 count++，此时就相当于两组 load、add、save 进行执行，此时不同的线程调度顺序，就可能产生一些结果上的差异：

这种线程是没有安全问题的：

thread1 线程先把内存中的值，读取到CPU的寄存器中，然后把 CPU 寄存器里的数值进行 +1 运行，最后把得到的结果写回到内存中。thread1 执行完这些后在由 thread2 执行，所以这种情况是没有线程安全问题的，但是我们知道多线程是抢占式执行、随机调度的，所以这种情况的比较少

这种线程是有安全问题的：

因为线程是抢占式执行、随机调度的，所以很有可能 thread1 刚把内存中的值，读取到CPU的寄存器中。就随机调度到 thread2 了，thread2 把load、add、save执行完后。又调度到 thread1 继续执行，可是 thread1 ，在 thread2 执行前就把值读取到 CPU 寄存器中了，那么读取到的值就是 thread2 未执行前的值，thread1 把之前读到的值 add、save一下，那不就有 bug 了么

3、解决线程安全问题

3.1 线程安全的原因

我们如果想要解决线程安全的问题，那么首先的知道线程安全的原因

线程安全的原因：

抢占式执行：随机调度，无能为力（根本原因）
代码结构：多个线程同时修改同一个变量
原子性：如果修改操作是原子的，也还好，因为原子是不可拆分的单位，如果修改操作是非原子的，出问题的概率就非常高了（例：count++ 这里可以拆分为 load add save 三个操作，原子单个指令无法进行拆分）
内存常见性问题：如果一个线程读，一个线程改就可能出现问题，此时读的操作可能结果不对
指令重排序：编译器优化出 bug 了，编译器觉得你自己的代码太垃圾了，就会自作主张把你的代码调整，保持逻辑不变的情况下，进行调整，从而加快程序的执行效率，调整代码的执行顺序

3.2 解决线程安全问题

上面我们了解了出现线程安全问题的原因，那接下来我们就针对线程安全问题，来谈谈它的解决方案

解决线程安全问题最主要的手段就是从原子性入手，把这个非原子的操作，变成原子的。那如何将其变成原子的呢？

答：加锁，通过加锁，把非原子的，转换成原子的

class CountAdd {
    public int count;
    
    //synchrozed：将非原子转换为原子，也就是加锁
    synchronized public void add() {
        count++;
    }
}

加了 synchronized 之后，进入方法就加锁，出来方法就解锁

如果两个线程同时尝试加锁，此时一个能获取锁成功，另一个就只能阻塞等待(BLOCKED)。一直阻塞到刚才的线程释放锁(解锁)，当前线程才能加锁成功

虽然加锁之后，速度慢了，但依然比单线程快。因为加锁只是针对 coun++ 加锁了，除了 count++ 之外，还有 for 循环的代码，for循环代码是可以并发执行的，只是 count++ 串行执行了

如果两个线程针对同一个对象进行加锁，就会出现锁竞争/锁冲突的问题，一个线程能够获取到锁(先到先得)，另一个线程阻塞等待，等待上一个线程解锁，它才能获取锁成功

public class Demo {
    public static void main(String[] args) {
        CountAdd countAdd = new CountAdd();
        Thread thread1 = new Thread(()->{
            for (int i = 1; i <= 50000; i++) {
                countAdd.add();
            }
        });
        Thread thread2 = new Thread(()->{
            for (int i = 1; i <= 50000; i++) {
                countAdd.add();
            }
        });
        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(countAdd.count);
    }
}

class CountAdd {
    public int count;
    synchronized public void add() {
        count++;
    }
}

运行结果：