当前位置：首页 > news >正文

浅谈线程安全问题的原因和解决方案

news 来源：原创 2025/5/1 16:14:54

1. 观察线程不安全

class Counter {
    public int count = 0;
    
    public void increase() {
        count++;
    }
    
}

// 线程安全问题演示.
public class Demo12 {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();

        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);
    }
}

上述的代码中两个线程, 针对同一个变量, 进行循环自增. 各自自增5w次，预期最终应该是10w, 但实际上,并不是这样的结果. 每次运行的结果都不一样, 并且还都是错的.

在多线程下，发现由于多线程执行，导致的bug, 统称为"线程安全问题". 如果某个代码, 在单线程下执行没有问题, 多个线程下执行也没问题, 则称为"线程安全"，反之就可以称为"线程不安全".

那么啥是bug呢? bug是一个非常广义的概念. bug 的中文名，可以翻译成"幺蛾子". 只要是实际运行效果和预期效果(需求中的效果)不一致，就可以称为是一个bug.

线程安全和线程不安全的区别也就是多线程代码是否有bug.

那么上述的代码为啥会出现bug呢?

如果上述操作, 在两个线程或者多个线程并发执行的情况下, 就可能会出现问题.

如果上述两个线程是这样串行执行的, 那么结果就会是对的. 但是真的能这样吗? 上述图片中虽然是只是自增两次，但是由于两个线程并发执行, 就可能在一定的执行顺序下，导致运算的中间结果就被覆盖了. 在这5w次的循环过程中, 有多少次这俩线程执行++是"串行的”?，有多少次会出现覆盖结果的? 这些都不确定. 因为线程的调度是随机的, 是抢占式执行的过程.

上述的过程就是结果被覆盖的例子. 此处这两个线程的调度是不确定的, 这两组对应的操作也会有差异. 而且上述代码得到的结果一定是小于100000的, 因为有结果被覆盖掉了.

2. 线程安全问题的原因

1) [根本原因]多个线程之间的调度顺序是"随机的", 操作系统使用"抢占式"执行的策略来调度线程．这就是罪魁祸首，万恶之源.

和单线程不同的是, 在多线程下, 代码的执行顺序,产生了更多的变化.
以往只需要考虑代码在一个固定的顺序下执行,执行正确即可. 现在则要考虑多线程下, N种执行顺序下，代码执行结果都得正确.
这件事情,木已成舟，咱们无力改变.当前主流的操作系统,都是这样的抢占式执行的.

2) 多个线程同时修改同一个变量就容易产生线程安全问题.

一个线程修改一个变量, 没事.

多个线程读取同一个变量, 没事.

多个线程修改多个变量, 没事.

3) 进行的修改, 不是"原子的".

如果修改操作，能够按照原子的方式来完成, 此时也不会有线程安全问题.
count++ 不是原子的~
= 直接赋值, 可以视为原子.
if = 先判定, 再赋值, 也不是原子的~~

所以解决线程安全, 最主要的切入手段就是"加锁".

"加锁"相当于是把一组操作, 给打包成一个"原子"的操作.
事务的那个原子操作, 主要是靠回滚. 此处这里的原子, 则是通过锁进行"互斥", 也就是这个线程进行工作的时候, 其他线程无法进行工作.

那根据上面的例子和代码, 我们就可以知道要给count++加锁, 使用synchronized关键字即可.

于是乎代码变动成了这样.

class Counter {
    public int count = 0;

    synchronized public void increase() {
        count++;
    }

}

// 线程安全问题演示.
public class Demo12 {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();

        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);
    }
}

那么就有一个问题了, 通过加锁操作之后, 把并发执行=>串行执行了. 此时, 多线程还有存在的意义嘛?

必然是有的. 代码中的线程并不是只做了count++这一件事, for循环并没有加锁, for循环中操作的变量i是栈上的一个局部变量. 两个线程, 是有两个独立的栈空间, 也就是完全不同的变量, 就不涉及到线程安全问题. 因此，这两个线程，有一部分代码是串行执行的, 有一部分是并发执行的, 就仍然要比纯粹的串行执行效率要高.

synchronized进行加锁解锁, 其实是以“对象"为维度进行展开的.

加锁目的是为了互斥使用资源.(互斥的修改变量)

synchronized每次加锁,也是针对某个特定的对象加锁!

如果两个线程针对同一个对象进行加锁
就会出现锁竞争/锁冲突(一个线程能加锁成功,另一个线程阻塞等待), 那么就可以解决线程安全问题.

具体是针对哪个对象加锁，不重要.
重要的是, 两个线程, 是不是针对同一个对象加锁.

就比如更改一下代码, 也一样可有算出正确答案.

class Counter {
    public int count = 0;

    private Object locker = new Object();

     public void increase() {
        synchronized (locker) {
            count++;
        }
    }

    public void increase2() {
        synchronized (locker) {
            count++;
        }
    }

}

// 线程安全问题演示.
public class Demo12 {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();

        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.increase2();
            }
        });

        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println(counter.count);
    }
}