多线程中的线程安全性问题（原因）

概念：线程不安全指的是程序在多线程的执⾏结果不符合预期。

下面有一个例子就很典型：
使用–和++方法在多线程中对同一个变量进行修改，得到的结果每一次都会不一样，和预想的值差别很大

static class Counter {
    private int num = 0;
    public void incrment(int count) {
        for (int i = 0; i < count; i++) {
            num++;
       }
   }
    public void decrment(int count) {
        for (int i = 0; i < count; i++) {
            num--;
       }
   }
    public int getNum() {
        return num;
   }
}
public static void main(String[] args) throws InterruptedException {
    int count = 10_0000;
    Counter counter = new Counter();
    Thread t1 = new Thread(() -> {
        counter.incrment(count);
   });
    t1.start();
    Thread t2 = new Thread(() -> {
        counter.decrment(count);
   });
    t2.start();
    t1.join();
    t2.join();
    System.out.println(counter.getNum());
}

线程不安全的因素有以下五种

1.抢占式执行

线程抢占式执行会出现狼多肉少的情况，会导致线程不安全，多线程中会有抢占式调度
线程的执行时间由线程自己来控制，工作执行完成后，主动通知系统切换到其他线程。

2.多个线程同时对一个变量进行修改。

就会出现，覆盖修改的问题，就导致了线程安全问题！

3.操作时非原子性操作

比如进行一个++操作就是一个非原子性操作
⽐如 n++，其实是由三步操作组成的：

1. 从内存把数据读到 CPU
2. 进⾏数据更新
3. 把数据写回到 CPU
   不保证原⼦性会给多线程带来什么问题？
   如果⼀个线程正在对⼀个变量操作，中途其他线程插⼊进来了，如果这个操作被打断了，结果就可能是错误的。

这点也和线程的抢占式调度密切相关. 如果线程不是 “抢占” 的, 就算没有原⼦性, 也问题不⼤。

4.内存可见性问题

可⻅性指, ⼀个线程对共享变量值的修改，能够及时地被其他线程看到。
Java 内存模型 (JMM): Java虚拟机规范中定义了Java内存模型.

线程之间的共享变量存在 主内存 (Main Memory).
每⼀个线程都有⾃⼰的 “⼯作内存” (Working Memory) .
当线程要修改⼀个共享变量的时候, 也会先修改⼯作内存中的副本, 再同步回主内存.
由于每个线程有⾃⼰的⼯作内存, 这些⼯作内存中的内容相当于同⼀个共享变量的 “副本”. 此时修
改线程1 的⼯作内存中的值, 线程2 的⼯作内存不⼀定会及时变化.

5.指令重排序

编译器优化的本质是调整代码的执⾏顺序，在单线程下没问题，但在多线程下容易出现混乱，从⽽造成线程安全问题。

6.使用Voalatile解决内存可见性问题和指令重排序问题

可以使用Voalatile解决内存可见性问题和指令重排序问题
当一个变量在该线程工作内存中有值了，就会导致该线程执行循环的时候不去读取主内存中的值，就会导致该变量值得不到刷新，voalatile强制下一次执行循环的时候，重新去读取内存中的值。
volatile 可以解决内存可⻅性和指令重排序的问题，代码在写⼊ volatile 修饰的变量的时候：
改变线程⼯作内存中volatile变量副本的值
将改变后的副本的值从⼯作内存刷新到主内存
代码在读取 volatile 修饰的变量的时候：
从主内存中读取volatile变量的最新值到线程的⼯作内存中
从⼯作内存中读取volatile变量的副本
volatile 缺点
volatile 虽然可以解决内存可⻅性和指令重排序的问题，但是解决不了原⼦性问题，因此对于 ++ 和 –
操作的线程⾮安全问题依然解决不了，⽐如以下代码：