线程安全问题（面试常考）

🍊一. 观察多线程下n++和n--操作

我们目前所知当一个变量n==0，n++了1000次并且 n--了1000次，我们的预期结果为0，但是当两个线程分别执行++和--操作时最后的结果是否为0呢？

看这样一段代码：

public class ThreadSafe {
    private static int n = 0;

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i = 0;i < 1000;i++){
                        n++;
                }
            }
        });
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i = 0;i < 1000;i++){
                        n--;
                }
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(n);
    }
}

看一下分别运行3次的结果：

从结果上看都没有达到我们的预期结果，因为两个线程同时操作一个共享变量时，这其中就涉及到线程安全问题

🍉二. 线程安全概念的引入

我们所知单线程下n++和n--同时执行1000次时结果为0，多线程下大部分不为0，所以我们简单定义为在多线程下和单线程下执行相同的操作结果相同时为线程安全

对于多个线程，操作同一个共享数据（堆里边的对象，方法区中的数据，如静态变量）：

如果都是读操作，也就是不修改值，这时不存在安全问题
如果至少存在写操作时，就会存在线程安全问题

🫐三. 线程不安全的原因

🌴1. 原子性

一组操作（一行或多行代码）是不可拆分的最小执行单位，就表示这组操作是具有原子性的

多个线程多次的并发并行的对一个共享变量操作时，该操作就不具有原子性

看这样一个例子，如下图：

这最终导致的结果是一张票被售卖了两次，这样就具有很大的风险性

注意：我们在写的一行Java代码可能不是原子性的，因为它编译成字节码，或者由JVM把字节码翻译为机器码后就不是一行，也就是多条执行操作

典型的n++，n--操作：

经过一次n++，n--操作后发现结果不为-1，原因是因为一次++或者--操作是分三步执行：

🍁从内存把数据读到CPU
🍁对数据进行更新操作
🍁再把更新后的操作写入内存

🌾2. 可见性

多个线程工作的时候都是在自己的工作内存中（CPU寄存器）来执行操作的，线程之间是不可见的

线程之间的共享变量存在主内存
每一个线程都有自己的工作内存
线程读取共享变量时，先把变量从主存拷贝到工作内存，再从工作内存读取数据
线程修改共享变量时，先修改工作内存中的变量值，再同步到主内存

🍬为什么要保证可见性？

对应上述n++，n--操作的例子，就是因为n++操作后未能将新的变量值及时同步到主存中，所以n--操作拿到的变量值是不准确的，而可见性就是确保更新后的共享变量的值能及时同步到主存中，确保别的线程从主存拿到的值都是最新的值

🌵3. 有序性

🍬了解重排序：

JVM翻译字节码指令，CPU执行机器码指令，都可能发生重排序来优化执行效率

比如有这样三步操作：(1) 去前台取U盘 (2) 去教室写作业 (3) 去前台取快递
JVM会对指令优化，也就是重排序，新的顺序为(1)(3)(2),这样来提高效率

🍒四. 解决线程不安全问题

🌿1. synchronized关键字-监视器锁（monitor lock）

🍂1.1 语法格式

1. 修饰普通方法，也叫同步实例方法

    public synchronized void doSomething(){
        //...
    }

等同于

    public void doSomething(){
        synchronized (this) {
            //...
        }
    }

2. 修饰静态方法，也叫静态同步方法

    public static synchronized void doSomething(){
        //...
    }

等同于

    public static void doSomething(){
        synchronized (A.class) {
            //...
        }
    }

3. 修饰代码块

    synchronized (对象) {
        //...
    }

🍂1.2 sychronized的作用

sychronized是基于对象头加锁的，特别注意：不是对代码加锁
一个对象在同一时间只能有一个线程获取到该对象的锁
sychronized保证了原子性，可见性，有序性

1. 互斥性

synchronized 会起到互斥效果, 某个线程执行到某个对象的 synchronized 中时, 其他线程如果也执行到同一个对象 synchronized 就会阻塞等待

进入 synchronized 修饰的代码块, 相当于 加锁
退出 synchronized 修饰的代码块, 相当于 解锁

看下图理解加锁过程：

阻塞等待：

针对每一把锁, 操作系统内部都维护了一个等待队列. 当这个锁被某个线程占有的时候,其他线程尝试进行加锁, 就加不上了，就会阻塞等待, 一直等到之前的线程解锁之后, 由操作系统唤醒一个新的线程, 再来获取到这个锁

2. 刷新主存

synchronized的工作过程：

🍃获得互斥锁
🍃从主存拷贝最新的变量到工作内存
🍃对变量执行操作
🍃将修改后的共享变量的值刷新到主存
🍃释放互斥锁

3. 可重入性

synchronized是可重入锁
同一个线程可以多次申请成功一个对象锁

如下情形：

🍂1.3 对n++，n--代码进行修改

public class ThreadSafe {
    private static int n = 0;

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i = 0;i < 1000;i++){
                    synchronized (ThreadSafe.class) {
                        n++;
                    }
                }
            }
        });
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i = 0;i < 1000;i++){
                    synchronized (ThreadSafe.class){
                        n--;
                    }
                }
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(n);
    }
}

结果：结果为我们预期结果，说明是线程安全的

🌴2. volatile关键字

volatile是用来修饰变量的，它的作用是保证可见性，有序性
注意：不能保证原子性，对n++，n--来说，用volatile修饰n也是线程不安全的

· 代码在写入 volatile 修饰的变量的时候,改变线程工作内存中volatile变量副本的值将改变后的副本的值从工作内存刷新到主内存
· 代码在读取 volatile 修饰的变量的时候,从主内存中读取volatile变量的最新值到线程的工作内存中
从工作内存中读取volatile变量的副本

使用场景：

读操作：读操作本身就是原子性，所以使用volatile就是线程安全的
写操作：赋值操作是一个常量值（写到主存），也保证了线程安全

用volatile修饰变量n看是否线程安全：

public class ThreadSafe {
    private static volatile int n = 0;

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i = 0;i < 1000;i++){
                        n++;
                }
            }
        });
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i = 0;i < 1000;i++){
                        n--;
                }
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(n);
    }
}

结果：也是不是线程安全的

🌳3. Lock（Java api提供的一个锁，后续在锁策略中介绍）