---

引言：

在多线程编程中，线程安全是一个至关重要的概念。线程安全可能到导致数据不一致，应用程序崩溃和其他不可预测的后果。本文将深入探讨线程安全问题的根本原因，并通过Java代码示例演示如何解决这些问题。

---

线程安全的根本原因

这里先观察一个线程不安全的例子：

public class Test {
    private static int count;

    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                count++;
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                count++;
            }
        });

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

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


        System.out.println(count);

    }
}

这里我们想要得到 count 的值为200，但是运行的结果却不是。

这里的 count++ 实际操作分为3步：

1. load把数据从内存，读到 cpu 寄存器中（可能先t1，也可能先t2）。

2. add 将寄存器中的数据进行 +1。

3. save 把寄存器中的数据，保存到内存中 。

因为线程的调度是随机的，所以在 count++ 时会出现下面等很多不同的结果

针对以上我们可以知道产生线程安全的原因：

1. 操作系统中，线程的调度是随机的

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

3. 修改操作，不是原子性的

    此处count++是 非原子 的操作（先读，再修改）

4. 内存可见性问题

解决线程安全

使用synchronized关键字可以将代码块或方法标记为同步的，这样只有一个线程可以访问它。这可以防止多个线程同时访问共享数据。

public class Test {
    private static int count;
    private static Object locker = new Object();

    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(() -> {
            synchronized (locker) {
                for (int i = 0; i < 100; i++) {
                    count++;
                }
            }
        });

        Thread t2 = new Thread(() -> {
            synchronized (locker) {
                for (int i = 0; i < 100; i++) {
                    count++;
                }
            }
        });

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

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


        System.out.println(count);

    }
}

这串代码，对其进行 synchroniezd 加锁后，答案就能是200了

synchronized 的特性

1. 互斥性

2.可重入性

互斥性

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

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

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

可重入性

在下面的代码中,increase 和 increase2 两个方法都加了 synchronized, 此处的 synchronized 都是针对 this 当前 对象加锁的. 在调用 increase2 的时候, 先加了一次锁, 执行到 increase 的时候, 又加了一次锁. (上个锁还没释 放, 相当于连续加两次锁)

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

死锁

哲学家就餐问题：

假设有几个哲学家，围着一个桌子（上有一盘菜），每两个人之间有1个筷子，哲学家吃饭的的时间是随机的，吃饭的时候会拿起左右两边的筷子（先拿左边的，没拿起右手的不会放下左手的），正常情况下是可以吃的，但是如果同时拿起左边的筷子，就 " 卡 "到这了 。

死锁的原因

1. 互斥使用，当一个线程持有一把锁时，另一个也想要得到锁，就必须阻塞等待（锁的基本特性）

2. 不可抢占，当锁已经被线程1拿到后，线程2只能等待1主动释放（锁的基本特性）

3. 请求保持，一个线程尝试获取多把锁（代码结构：下面例子）

4. 循环等待（代码结构：哲学家就餐问题）

解决死锁

所以解决死锁1，和 2是锁的本质不能改变

我们只能调整：

对于3来说，改变代码结构

对于4来说，约定加锁的顺序

volatile关键字

1. 保存内存可见性

2. 不保证原子性

保存内存可见性

讨论内存可见性的话，就不得不谈论一下下面的知识点：

计算机cpu访问数据（存在内存中）的时候，会先读出来，放到寄存器中，再进行运算。cpu读内存的操作相对于其他操作来说是比较慢的。所以编译器为了提高效率，把本来要读内存的操作，优化成了读寄存器，减少了读内存的操作。eg：

public class Demo17 {
    private static volatile int isQuit = 0;

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            while (isQuit == 0) {
                // 循环体里啥都没干.
                // 此时意味着这个循环, 一秒钟就会执行很多很多次.
            }
            System.out.println("t1 退出!");
        });
        t1.start();

        Thread t2 = new Thread(() -> {
            System.out.println("请输入 isQuit: ");
            Scanner scanner = new Scanner(System.in);
            // 一旦用户输入的值, 不为 0, 此时就会使 t1 线程执行结束.
            isQuit = scanner.nextInt();
        });
        t2.start();
    }
}

这里即使你输入的不是0，也会一直循环！！！

因此为解决这个问题，就可以在变量的前面加上volatile！！！