引言：
在多线程编程中，线程安全是一个至关重要的概念。线程安全可能到导致数据不一致，应用程序崩溃和其他不可预测的后果。本文将深入探讨线程安全问题的根本原因，并通过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！！！
