Java中的多线程安全问题_说说java并发运行中的一些安全问题

目录

一、什么是线程安全？

二、线程不安全的原因

2.1 从底层剖析count++的操作

2.2 线程不安全的原因总结

2.3 JVM内存模型（JMM）

三、synchronized 关键字-监视器锁monitor lock

 3.1 如何加锁（Synchronized用法和特性）

3.1.1. 独占性

3.1.2 可重入性

四、Java 标准库中的线程安全类

五、volatile关键字

5.1 volatile可以保证内存可见性

5.2 volatile不可以保证原子性

---

一、什么是线程安全？

简单的理解：如果多线程环境下代码运行的结果是符合我们预期的，即在单线程环境应该的结果，则说这个程序是线程安全的。

观察一下代码：使用两个线程，每个线程都对这个 Counter进行5w次自增，预计是结果为10w。

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: 86136
 * Date: 2023-01-12
 * Time: 20:50
 */
class Counter {
    public int count = 0;
 
    public void increase() {
        count++;
    }
}
public class Demo13 {
    static Counter counter = new Counter();
    public static void main(String[] args) throws InterruptedException {
        //使用两个线程，每个线程都对这个 Counter进行5w次自增
        //预计是结果为10w
 
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5_0000; i++) {
                counter.increase();
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5_0000; i++) {
                counter.increase();
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(counter.count);
    }
}

运行结果：

二、线程不安全的原因

上面我们使用了多线程运行了一个程序，想让这个变量从0自增到10w次，但是最终实际结果比我们预期的结果要小，这是线程调度顺序的随机性导致的，造成了线程间自增的指令集交叉，导致本来需要自增两次但值只自增了一次的情况。所以得到的结果偏小。

2.1 从底层剖析count++的操作

count++ 操作，在底层其实是被分为三条指令在CPU上进行执行的

1. 把内存的数据读取到CPU的寄存器上（load)
2. 把CPU的寄存器中的值，进行+1（add）
3. 把寄存器中的值，写回到内存中（save）

这里简单的描述几种情况，初始条件：初始值为1，对其进行两次自增。