线程安全问题(1)-CSDN博客

本文链接：https://blog.csdn.net/m0_74859835/article/details/132548162

一，线程安全问题

有些代码在单个线程的环境下运行，完全正确，但是同样的代码，让多个线程去执行，此时就可能出现BUG，这就是所谓的 "线程安全问题"。举一个例子：

public class Demo {
    static int count = 0;
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{
            for (int i = 0; i < 5000; i++) {
                count++;
            }
        });
        Thread thread1 = new Thread(()->{
            for (int i = 0; i < 5000; i++) {
                count++;
            }
        });
        thread.start();
        thread1.start();

        thread.join();
        thread1.join();
        System.out.println("count = "+count);
    }
}

以上代码如果使用单线程执行，他的答案是10000，但是如果使用多线程，那么就不确定了。

那么为什么会出现这种情况呢？首先我们要深入了解一下 count++ 这个操作，实际上这个操作是分成 3 步执行的(站在CPU的角度，count++，是有三个指令实现的)：

load 把数据从内存读取到 CPU 寄存器中 ——> tmp = count (简单理解版)
add 把寄存器中的数据进行 +1 ——> tmp += 1 (简单理解版)
save 把寄存器中的数据，保存到内存中 ——> count = tmp (简单理解版)

在此基础上，又因为线程之间的调度顺序是随机的，就会导致上面的代码出BUG，画一个图来理解一下：

（上面画的只是一部分情况），也就是说，两个线程分别自增一次，预期得到的是2，实际上可能得到的是1，这就会导致两个线程的结果没有向上累加，而是各自独立运行。

讲了上面的BUG后，还有一个问题，我们得到的count的可能取值范围是多少？是[1，10000]，还是[5000，10000]？答案是 [1，10000]，因为可能线程1 自增1次，而线程2 自增 n 次，画个图理解一下：

二，线程安全问题产生原因

1. 操作系统中，线程的调度顺序是随机的(抢占式执行)

线程的调度顺序是在系统内核实现的，无法解决

2. 两个线程，针对同一个变量进行修改

一个线程针对一个变量进行修改 ✔️

两个线程针对不同变量进行修改 ✔️

两个线程针对同一个变量进行读取 ✔️

3. 修改操作不是原子的，拿上面的举例就是：count++这个操作不是一步到位的，需要分成4三步执行。

原子性：将多个操作"封装"起来，使其就相当于一个操作，更加通俗一点，就相当于

有一个房间，当线程1在该房间执行操作时，线程2要么等待，要么去其他房间执行

4. 内存可见性问题(这章还不涉及)

5. 指令重排序问题(这章还不涉及)

三，解决线程安全问题

上面讲了5种原因导致线程安全问题，其中1是避免不了的，2是只能在写代码时尽量避免，4，5还没涉及到，因此我们要想解决线程安全问题就只能从原因3入手，即将那些非原子操作转换成原子操作，更加专业一点就是 "加锁"。

在Java中，给代码"加锁"最常见的办法就是使用 synchronized 关键字：

synchronized( ){

......

//要执行的操作放在这里

}

注：（）中需要一个用来加锁的对象。这个对象的类型不重要，重要的是通过这个对象来区分两个线程是否竞争同一个锁，如果两个线程是在竞争同一个锁，就会有锁竞争，如果不是，就不会有锁竞争，就任然是并发执行。

你可以将锁想象成一个单人的自习室，如果你先占用了这个自习室，那么其他人要么阻塞等待你使用结束（锁竞争），要么去其他空的自习室（没有锁竞争）。

public class Demo {
    static int count = 0;
    public static void main(String[] args) throws InterruptedException {
        Object locker = new Object();//锁
        Thread thread = new Thread(()->{
            synchronized (locker){
                for (int i = 0; i < 5000; i++) {
                    count++;
                }
            }
        });
        Thread thread1 = new Thread(()->{
            synchronized (locker){
                for (int i = 0; i < 5000; i++) {
                    count++;
                }
            }
        });
        thread.start();
        thread1.start();

        thread.join();
        thread1.join();
        System.out.println("count = "+count);
    }
}

在画个图对比一下：

四，synchronized的其他用法

synchronized 关键字除了上述的用法外，还可以用来修饰静态方法和非静态方法，来达到 "加锁" 的目的。例如：

class Counter{
    int count = 0;
    static int a = 0;

    //下面两个是针对非静态变量的不同写法
    synchronized public void addCount(){
        count++;
    }
    public void addCount2(){
        synchronized (this){
            count++;
        }
    }

    //这两个是针对静态变量的不同写法
    synchronized public static void increase(){
        a++;
    }
    public static void increase2(){
        synchronized (Counter.class){
            a++;
        }
    }
}