2. 多线程带来的风险

一、线程安全问题

1. 观察线程不安全

java">class Demo{// 此处定义⼀个 int 类型的变量private static int count = 0;public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(() -> {// 对 count 变量进⾏⾃增 5w 次 for (int i = 0; i < 50000; i++) {count++;}});Thread t2 = new Thread(() -> {// 对 count 变量进⾏⾃增 5w 次 for (int i = 0; i < 50000; i++) {count++;}});t1.start();t2.start();// 如果没有这俩 join, 肯定不⾏的. 线程还没⾃增完, 就开始打印了. 很可能打印出来的 cout1.join();t2.join();// 预期结果应该是 10w System.out.println("count: " + count);}
}

实际打印结果每次都不一样。

2. 线程安全的概念

想给出一个线程安全的确切定义是复杂的，但我们可以这样认为：如果多线程环境下代码运行的结果是符合我们预期的，即在单线程环境应该的结果，则说这个程序是线程安全的。

3. 线程不安全的原因

线程调度是随机的

这是线程安全问题的根本。随机调度使一个程序在多线程环境下，执行顺序存在很多的变数，我们必须保证在任意执行顺序下，代码都能正常工作。

修改共享数据

多个线程修改同⼀个变量。上⾯的线程不安全的代码中，涉及到多个线程针对 count 变量进⾏修改。此时这个 count 是⼀个多个线程都能访问到的 “共享数据”。

原子性

什么是原子性？
我们把一段代码想象成一个房间，每个线程就是要进入这个房间的人。如果没有任何机制保证，A进入房间之后，还没有出来；B是不是也可以进入房间，打断A在房间里的隐私。这个就是不具备原子性的。
那应该如何解决这个问题呢？是不是只要给房间加一把锁，A进去就把门锁上，其他人是不是就进不来了。这样就保证了这段代码的原子性了。有时也把这个现象叫做同步互斥，表示操作是互相排斥的。
一条 Java 语句不一定是原子的，也不一定只是一条指令。比如刚才我们看到的 count++，其实是由三步操作组成的：

从内存把数据读到 CPU；
进行数据更新；
把数据写回到CPU。

不保证原子性会给多线程带来什么问题？
如果一个线程正在对一个变量操作，中途其他线程插入进来了，如果这个操作被打断了，结果就可能是错误的。这点也和线程的抢占式调度密切相关，如果线程不是“抢占”的，就算没有原子性，也问题不大。

可见性

可见性是指一个线程对共享变量值的修改，能够及时地被其他线程看到。

Java 内存模型 (JMM)：Java虚拟机规范中定义了Java内存模型，目的是屏蔽掉各种硬件和操作系统的内存访问差异，以实现让Java程序在各种平台下都能达到一致的并发效果。

线程之间的共享变量存放在主内存(Main Memory)。
每一个线程都有自己的 “工作内存”(Working Memory)。
当线程要读取一个共享变量的时候，会先把变量从主内存拷贝到工作内存，再从工作内存读取数据。
当线程要修改一个共享变量的时候，也会先修改工作内存中的副本，再同步回主内存。

由于每个线程有自己的工作内存，这些工作内存中的内容相当于同一个共享变量的“副本”，此时修改线程1的工作内存中的值，线程2的工作内存不一定会及时变化。比如：

(1) 初始情况下，两个线程的工作内存内容一致。

(2) 一旦线程1修改了a的值，此时主内存不一定能及时同步，对应的线程2的工作内存的 a 的值也不一定能及时同步。

这个时候代码中就容易出现问题。

【问题】

1. 为啥要整这么多内存？

答：实际并没有这么多“内存”。这只是 Java 规范中的一个术语，是属于“抽象”的叫法。所谓的“主内存”才是真正硬件角度的“内存”，而所谓的“工作内存”，则是指 CPU 的寄存器和高速缓存。

2. 为啥要这么麻烦的拷来拷去?
因为 CPU 访问自身寄存器的速度以及高速缓存的速度远远超过访问内存的速度(快了3-4个数量级也就是几千倍，上万倍)。比如某个代码中要连续 10 次读取某个变量的值，如果 10 次都从内存读，速度是很慢的，但是如果只是第一次从内存读，读到的结果缓存到 CPU 的某个寄存器中，那么后 9 次读数据就不必直接访问内存了，效率就大大提高了。

指令重排序

什么是代码重排序？⼀段代码是这样的：

去前台取下 U 盘；
去教室写 10 分钟作业；
去前台取下快递。

如果是在单线程情况下，JVM、CPU指令集会对其进行优化，比如，按1->3->2的方式执行，也是没问题，可以少跑一次前台。这种叫做指令重排序。

编译器对于指令重排序的前提是“保持逻辑不发生变化”，这一点在单线程环境下比较容易判断，但是在多线程环境下就没那么容易了，多线程的代码执行复杂程度更高，编译器很难在编译阶段对代码的执行效果进行预测，因此激进的重排序很容易导致优化后的逻辑和之前不等价。

4. 解决之前的线程不安全问题

java">class Demo{// 此处定义⼀个 int 类型的变量private static int count = 0;public static void main(String[] args) throws InterruptedException {Object locker = new Object();Thread t1 = new Thread(() -> {// 对 count 变量进⾏⾃增 5w 次for (int i = 0; i < 50000; i++) {synchronized (locker) {count++;}}});Thread t2 = new Thread(() -> {// 对 count 变量进⾏⾃增 5w 次for (int i = 0; i < 50000; i++) {synchronized (locker) {count++;}}});t1.start();t2.start();// 如果没有这俩 join, 肯定不⾏的. 线程还没⾃增完, 就开始打印了. 很可能打印出来的 cout1.join();t2.join();// 预期结果应该是 10wSystem.out.println("count: " + count);}
}

二、synchronized 关键字

1. synchronized 的特性

1.1 互斥

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

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

synchronized 用的锁是存在Java对象头里的。

可以粗略理解成，每个对象在内存中存储的时候，都存有一块内存表示当前的"锁定"状态(类似于厕所的"有人/无人")。
如果当前是"无人"状态，那么就可以使用，使用时需要设为"有人"状态。

如果当前是"有人"状态，那么其他人无法使用，只能排队。

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

上一个线程解锁之后，下一个线程并不是立即就能获取到锁，而是要靠操作系统来"唤醒"。这也就是操作系统线程调度的一部分工作。
假设有 ABC 三个线程，线程A先获取到锁，然后 B 尝试获取锁，然后 C 再尝试获取锁，此时 B 和 C 都在阻塞队列中排队等待，但是当 A 释放锁之后，虽然 B 比 C 先来的，但是 B 不一定就能获取到锁而是和 C 重新竞争，并不遵守先来后到的规则。

1.2 可重入

synchronized 同步块对同⼀条线程来说是可重入的，不会出现自己把自己锁死的问题。

理解“把自己锁死”：
一个线程没有释放锁，然后又尝试再次加锁。
// 第一次加锁，加锁成功；
lock();
//第二次加锁，锁已经被占用，阻塞等待。

lock();
按照之前对于锁的设定，第二次加锁的时候，就会阻塞等待，直到第一次的锁被释放，才能获取到第二个锁，但是释放第一个锁也是由该线程来完成，结果这个线程已经躺平了，啥都不想干了，也就无法进行解锁操作，这时候就会死锁。

这样的锁称为不可重入锁。

Java 中的 synchronized 是可重入锁，因此没有上面的问题。

java">for (int i = 0; i < 50000; i++) {synchronized (locker) {synchronized (locker) {count++;}}
}

在可重入锁的内部，包含了“线程持有者”和“计数器”两个信息。

如果某个线程加锁的时候，发现锁已经被人占用，但是恰好占用的正是自己，那么仍然可以继续获取到锁，并让计数器自增；
解锁的时候计数器递减为 0 的时候，才真正释放锁。(才能被别的线程获取到)

2. synchronized 使用示例

synchronized 本质上要修改指定对象的“对象头”，从使用角度来看，synchronized 也势必要搭配一个具体的对象来使用。

2.1 修饰代码块

明确指定锁哪个对象：

锁任意对象

java">public class SynchronizedDemo {private Object locker = new Object();public void method() {synchronized (locker) {}}
}

锁当前对象

java">public class SynchronizedDemo {public void method() {synchronized (this) {}}
}

2.2 直接修饰普通方法

锁的 SynchronizedDemo 实例对象，即 this 所指向的对象。

java">public class SynchronizedDemo {public synchronized void methond() {}
}

2.3 修饰静态方法

锁的 SynchronizedDemo 类的对象，即 SynchronizedDemo.class 。

java">public class SynchronizedDemo {public synchronized static void method() {}
}

3. Java 标准库中的线程安全类

Java 标准库中很多都是线程不安全的，这些类可能会涉及到多线程修改共享数据，又没有任何加锁措施。比如：

ArrayList
LinkedList
HashMap
TreeMap
HashSet
TreeSet
StringBuilder

但是还有⼀些是线程安全的，使用了⼀些锁机制来控制。比如：

Vector（不推荐使用）
HashTable （不推荐使用）
ConcurrentHashMap
StringBuffer

StringBuffer 的核心方法都带有 synchronized 关键字。

还有的虽然没有加锁，但是不涉及“修改”，仍然是线程安全的。比如：

String

三、volatile 关键字

1. volatile 能保证内存可见性

volatile 修饰的变量，能够保证“内存可见性”。

代码在写入 volatile 修饰的变量的时候

先将改变线程工作内存中volatile变量副本的值；
然后将改变后的副本的值从工作内存刷新到主内存。

代码在读取 volatile 修饰的变量的时候

先从主内存中读取volatile变量的最新值到线程的工作内存中；
然后从工作内存中读取volatile变量的副本。

前面讨论内存可见性时说了，直接访问工作内存（实际是 CPU 的寄存器或者 CPU 的缓存），速度非常快，但是可能出现数据不一致的情况。加上 volatile，强制读写内存，速度是慢了，但是数据变得更准确了。

代码示例：

在这个代码中，创建两个线程 t1 和 t2，t1中包含一个循环，这个循环以 flag==0 为循环条件，t2 中从键盘读入一个整数，并把这个整数赋值给 flag，预期当用户输入非0的值的时候，t1线程结束。

java">class Counter{public int flag = 0;
}
public class Demo {public static void main1(String[] args) {Counter counter = new Counter();Thread t1 = new Thread(()->{while (counter.flag ==0){// do nothing}System.out.println("循环结束！");});Thread t2 = new Thread(()->{Scanner scanner = new Scanner(System.in);System.out.println("请输入一个整数：");counter.flag = scanner.nextInt();});t1.start();t2.start();}
}// 执⾏效果 
// 当⽤⼾输⼊⾮0值时, t1 线程循环不会结束. (这显然是⼀个 bug)

t1 读的是自己工作内存中的内容当，t2 对 flag 变量进行修改，此时 t1 感知不到 flag 的变化，如果给 flag 加上 volatile 。

java">class Counter{public volatile int flag = 0;
}// 执⾏效果 
// 当⽤⼾输⼊⾮0值时, t1 线程循环能够⽴即结束.