并发编程三大特性

原子性

一个操作或者多次操作，要么所有的操作全部都得到执行并且不会受到任何因素的干扰而中断，要么所有的操作都执行，要么都不执行。

对于基本数据类型的访问，读写都是原子性的【long 和 double 可能例外】。

如果需要更大范围的原子性保证，可以使用 synchronized 关键字满足。

可见性

当一个变量对共享变量进行了修改，另外的线程都能立即看到修改后的最新值。

volatile保证共享变量可见性，除此之外，synchronized和final都可以 实现可见性。

synchronized：对一个变量执行 unclock 之前，必须先把此变量同步回主内存中。

final：被 final 修饰的字段在构造器中一旦被初始化完成，并且构造器没有把 this 的引用传递出去，其他线程中就能够看见 final 字段的值。

有序性

即程序执行的顺序按照代码的先后顺序执行【由于指令重排序的存在，Java 在编译器以及运行期间对输入代码进行优化，代码的执行顺序未必就是编写代码时候的顺序】，volatile通过禁止指令重排序保证有序性，除此之外，synchronized关键字也可以保证有序性，由【一个变量在同一时刻只允许一条线程对其进行 lock 操作】这条规则获得。

CPU 缓存模型是什么

高速缓存为何出现？

计算机在执行程序时，每条指令都是在 CPU 中执行的，而执行指令过程中，势必涉及到数据的读取和写入。由于程序运行过程中的**临时数据是存放在主存（物理内存）**当中的，这时就存在一个问题，由于 CPU 执行速度很快，而从内存读取数据和向内存写入数据的过程跟 CPU 执行指令的速度比起来要慢的多，因此如果任何时候对数据的操作都要通过和内存的交互来进行，会大大降低指令执行的速度。

为了解决 CPU 处理速度和内存不匹配的问题，CPU Cache 出现了。

图源：JavaGuide

缓存一致性问题

当程序在运行过程中，会将运算需要的数据从主存复制一份到 CPU 的高速缓存当中，那么 CPU 进行计算时就可以直接从它的高速缓存读取数据和向其中写入数据，当运算结束之后，再将高速缓存中的数据刷新到主存当中。

在单线程中运行是没有任何问题的，但是在多线程环境下问题就会显现。举个简单的例子，如下面这段代码：

i = i + 1;

按照上面分析，主要分为如下几步：

• 从主存读取 i 的值，复制一份到高速缓存中。

• CPU 执行执行执行对 i 进行加 1 操作，将数据写入高速缓存。

• 运算结束后，将高速缓存中的数据刷新到内存中。

多线程环境下，可能出现什么现象呢？

• 初始时，两个线程分别读取 i 的值，存入各自所在的 CPU 高速缓存中。

• 线程 T1 进行加 1 操作，将 i 的最新值 1 写入内存。

• 此时线程 T2 的高速缓存中 i 的值还是 0，进行加 1 操作，并将 i 的最新值 1 写入内存。

最终的结果 i = 1 而不是 i = 2，得出结论：如果一个变量在多个 CPU 中都存在缓存（一般在多线程编程时才会出现），那么就可能存在缓存不一致的问题。

如何解决缓存不一致

解决缓存不一致的问题，通常来说有如下两种解决方案【都是在硬件层面上提供的方式】：

通过在总线加 LOCK#锁的方式

在早期的 CPU 当中，是通过在总线上加 LOCK#锁的形式来解决缓存不一致的问题。因为 CPU 和其他部件进行通信都是通过总线来进行的，如果对总线加 LOCK#锁的话，也就是说阻塞了其他 CPU 对其他部件访问（如内存），从而使得只能有一个 CPU 能使用这个变量的内存。比如上面例子中 如果一个线程在执行 i = i +1，如果在执行这段代码的过程中，在总线上发出了 LCOK#锁的信号，那么只有等待这段代码完全执行完毕之后，其他 CPU 才能从变量 i 所在的内存读取变量，然后进行相应的操作。这样就解决了缓存不一致的问题。

但，有一个问题，在锁住总线期间，其他 CPU 无法访问内存，导致效率低下，于是就出现了下面的缓存一致性协议。

通过缓存一致性协议

较著名的就是 Intel 的 MESI 协议，MESI 协议保 S 证了每个缓存中使用的共享变量的副本是一致的。

当 CPU 写数据时，如果发现操作的变量是共享变量，即在其他 CPU 中也存在该变量的副本，会发出信号通知其他 CPU 将该变量的缓存行置为无效状态，因此当其他 CPU 需要读取这个变量时，发现自己缓存中缓存该变量的缓存行是无效的【嗅探机制：每个处理器通过嗅探在总线上传播的数据来检查自己的缓存的值是否过期】，那么它就会从内存重新读取。

基于 MESI 一致性协议，每个处理器需要不断从主内存嗅探和 CAS 不断循环，无效交互会导致总线带宽达到峰值，出现总线风暴。

JMM 内存模型是什么

JMM【Java Memory Model】：Java 内存模型，是 java 虚拟机规范中所定义的一种内存模型，Java 内存模型是标准化的，屏蔽掉了底层不同计算机的区别，以实现让 Java 程序在各种平台下都能达到一致的内存访问效果。

它描述了 Java 程序中各种变量【线程共享变量】的访问规则，以及在 JVM 中将变量存储到内存和从内存中读取变量这样的底层细节。

注意，为了获得较好的执行性能，<u style="margin: 0px; padding: 0px;">Java 内存模型并没有限制执行引擎使用处理器的寄存器或者高速缓存来提升指令执行速度，也没有限制编译器对指令进行重排序。</u>也就是说，在 java 内存模型中，也会存在缓存一致性问题和指令重排序的问题。

JMM 的规定

所有的共享变量都存储于主内存，这里所说的变量指的是【实例变量和类变量】，不包含局部变量，因为局部变量是线程私有的，因此不存在竞争问题。

每个线程都有自己的工作内存（类似于前面的高速缓存）。线程对变量的所有操作都必须在工作内存中进行，而不能直接对主存进行操作。

每个线程不能访问其他线程的工作内存。

Java 对三大特性的保证

原子性

在 Java 中，对基本数据类型的变量的读取和赋值操作是原子性操作，即这些操作是不可被中断的，要么执行，要么不执行。

为了更好地理解上面这句话，可以看看下面这四个例子：

x = 10;    //1y = x;     //2x ++;      //3x = x + 1;  //4

1. 只有语句 1 是原子性操作：直接将数值 10 赋值给 x，也就是说线程执行这个语句的会直接将数值 10 写入到工作内存中。

2. 语句 2 实际包含两个操作：先去读取 x 的值，再将 x 的值写入工作内存，虽然两步分别都是原子操作，但是合起来就不能算作原子操作了。

3. 语句 3 和 4 表示：先读取 x 的值，进行加 1 操作，写入新的值。

需要注意的点：

• 在 32 位平台下，对 64 位数据的读取和赋值是需要通过两个操作来完成的，不能保证其原子性。在目前 64 位 JVM 中，已经保证对 64 位数据的读取和赋值也是原子性操作了。

• Java 内存模型只保证了基本读取和赋值是原子性操作，如果要实现更大范围操作的原子性，可以通过 synchronized 和 Lock 来实现。

可见性

Java 提供了 volatile 关键字来保证可见性。

当一个共享变量被 volatile 修饰时，它会保证修改的值会立即被更新到主存，当有其他线程需要读取时，它会去内存中读取新值。

另外，通过 synchronized 和 Lock 也能够保证可见性，synchronized 和 Lock 能保证同一时刻只有一个线程获取锁然后执行同步代码，并且在释放锁之前会将对变量的修改刷新到主存当中。因此可以保证可见性。

有序性

在 Java 内存模型中，允许编译器和处理器对指令进行重排序，但是重排序过程不会影响到单线程程序的执行，却会影响到多线程并发执行的正确性。

在 Java 里面，可以通过 volatile 关键字来保证有序性，另外也可以通过 synchronized 和 Lock 来保证有序性。

Java 内存模型具备一些先天的有序性，前提是两个操作满足 happens-before 原则，摘自《深入理解 Java 虚拟机》：

• 程序次序规则：一个线程内，按照代码顺序，书写在前面的操作先行发生于书写在后面的操作【让程序看起来像是按照代码顺序执行，虚拟机只会对不存在数据依赖性的指令进行重排序，只能保证单线程中执行结果的正确性，多线程结果正确性却无法保证】

• 锁定规则：一个 unLock 操作先行发生于后面对同一个锁额 lock 操作

• volatile 变量规则：对一个变量的写操作先行发生于后面对这个变量的读操作

• 传递规则：如果操作 A 先行发生于操作 B，而操作 B 又先行发生于操作 C，则可以得出操作 A 先行发生于操作 C

• 线程启动规则：Thread 对象的 start()方法先行发生于此线程的每个一个动作

• 线程中断规则：对线程 interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生

• 线程终结规则：线程中所有的操作都先行发生于线程的终止检测，我们可以通过 Thread.join()方法结束、Thread.isAlive()的返回值手段检测到线程已经终止执行

• 对象终结规则：一个对象的初始化完成先行发生于他的 finalize()方法的开始

如果两个操作的执行次序无法从 happens-before 原则推导出来，那么它们就不能保证它们的有序性，虚拟机可以随意地对它们进行重排序。

volatile 解决的问题

• 保证了不同线程对共享变量【类的成员变量，类的静态成员变量】进行操作是时的可见性，一个线程修改了某个变量的值，新值对其他线程来说是立即可见的。

• 禁止指令重排序。

举个简单的例子，看下面这段代码：

//线程1boolean volatile stop = false;while(!stop){    doSomething();}//线程2stop = true;

1. 线程 1 和 2 各自都拥有自己的工作内存，线程 1 和线程 2 首先都会将 stop 变量的值拷贝一份放到自己的工作内存中，

2. 共享变量 stop 通过 volatile 修饰，线程 2 将 stop 的值改为 true 将会立即写入主内存。

3. 线程 2 写入主内存之后，导致线程 1 工作内存中缓存变量 stop 的缓存行无效。

4. 线程 1 的工作内存中缓存变量 stop 的缓存行无效，导致线程 1 会再次从主存中读取 stop 值。

volatile 保证原子性吗？怎么解决？

volatile 无法保证原子性，如对一个 volatile 修饰的变量进行自增操作i ++，无法保证多线程下结果的正确性。

解决方法：

• 使用 synchronized 关键字或者 Lock 加锁，保证某个代码块 在同一时刻只能被一个线程执行。

• 使用 JUC 包下的原子类，如 AtomicInteger 等。【Atomic 利用 CAS 来实现原子操作】。

volatile 的实现原理

下面这段话摘自《深入理解 Java 虚拟机》：

观察加入 volatile 关键字和没有加入 volatile 关键字时所生成的汇编代码发现，加入 volatile 关键字时，会多出一个 lock 前缀指令。

lock 前缀指令实际上相当于一个内存屏障（也成内存栅栏），内存屏障会提供 3 个功能：

• 它确保指令重排序时不会把其后面的指令排到内存屏障之前的位置，也不会把前面的指令排到内存屏障的后面；即在执行到内存屏障这句指令时，在它前面的操作已经全部完成；

• 它会强制将对缓存的修改操作立即写入主存；

• 如果是写操作，它会导致其他 CPU 中对应的缓存行无效。

volatile 和 synchronized 的区别

volatile 变量读操作的性能消耗与普通变量几乎没有什么差别，但是写操作则会慢一些，因为它需要在本地代码中插入许多内存屏障指令来保证处理器不发生乱序执行。不过即便如此，大多数场景下 volatile 的总开销仍然要比锁来的低。

• volatile 只能用于变量，而 synchronized 可以修饰方法以及代码块。

• volatile 能保证可见性，但是不能保证原子性。synchronized 两者都能保证。如果只是对一个共享变量进行多个线程的赋值，而没有其他的操作，推荐使用 volatile，它更加轻量级。

• volatile 关键字主要用于解决变量在多个线程之间的可见性，而 synchronized 关键字解决的是多个线程之间访问资源的同步性。

volatile 的使用条件

使用 volatile 必须具备两个条件【保证原子】：

• 对变量的写操作不依赖于当前值。

• 该变量没有包含在具有其他变量的不变式中。

最后

如果觉得本文对你有帮助的话，不妨给我点个赞，关注一下吧！

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录