虽然CPU的发展频率不断地得到提升，但受制于制造工艺以及成本的限制，计算机的内存反倒在访问速度上没有多大的提升，因此CPU的处理速度和内存的访问速度之间的差距越来越大，通常这种差距可以达到上千倍，极端情况下甚至会在上万倍以上。
在CPU和主内存之间增加缓存的设计，现在缓存的数量都可以增加到3级了，最靠近CPU的缓存称为L1，然后依次是L2，L3和主内存，如下图：
Cache的出现是为了解决CPU直接访问内存效率低下问题的，程序在运行过程中，会将运算所需要的数据从主内存复制一份到CPU Cache中，CPU在进行计算时就可以直接对CPU Cache中的数据进行读取和写入，当计算完成后，再将CPU Cache中的最新数据刷新到主内存当中，极大的提高了CPU吞吐能力。
由于缓存的出现，极大地提高了CPU的吞吐能力，但同时也引入了缓存不一致的问题，对于I++这个操作，在程序的运行过程中，首先将主内存中的数据复制一份存放到CPU Cache中，那么CPU寄存器在进行数值计算的时候就直接到Cache中读取和写入，当整个过程运算结束之后再将Cache中数据刷新到主内存中，具体过程如下：
读取操作，不做任何处理，只是将Cache中的数据读取到寄存器中。 写入操作，发出信号通知其他CPU将该变量的Cache line设置为无效状态，其他CPU在进行该变量读取的时候不得不到主内存中再次获取（即获取到最新的值）。
JMM决定一个线程对共享变量的写入何时对另其他线程可见。 所有的共享变量都存储于主内存（所有线程都可以访问），这里所说的变量指的是实例变量和类变量，不包含局部变量，因为局部变量是线程私有的，因此不存在竞争问题。 每一个线程还存在自己的工作内存（私有的），线程的工作内存，保留了被线程使用的共享变量的副本。 线程对变量的所有的操作(读，取)都必须在工作内存中完成，首先要将共享变量从主内存拷贝到自己的工作内存中，然后对变量进行操作，操作完成后再将变量写会主内存，而不能直接读写主内存中的变量。 不同线程之间也不能直接访问对方工作内存中的变量，线程间变量的值的传递需要通过主内存中转来完成。
一个线程对共享变量的修改，另外一个线程能够立刻看到（CPU缓存引起）。一个操作或者多个操作，要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行（分时复用、线程切换引起）。程序执行的顺序按照代码的先后顺序执行（指令重排序引起）。
通过这个概念来阐述操作之间的内存可见性。如果一个操作执行的结果需要对另一个操作可见，那么这两个操作之间必须存在happens-before关系。这里提到的两个操作既可以是在一个线程之内，也可以是在不同线程之间。如果A线程的写操作a与B线程的读操作b之间存在happens-before关系，尽管a操作和b操作在不同的线程中执行，但JMM保证a操作将对b操作可见。 如果一个操作happens-before另一个操作，那么第一个操作的执行结果将对第二个操作可见，并且第一个操作的执行顺序排在第二个操作之前。 如果两个操作之间存在happens-before关系，并不意味着Java平台的具体实现必须要按照happens-before关系指定的顺序来执行。如果重排序之后的执行结果，与按happens-before关系来执行的结果一致，那么这种重排序并不非法（也就是说，JMM允许这种重排序）。
一个线程内，按照代码顺序，写在前面的操作happens-before（先行发生）于任意后续操作。也就是说前一个操作的结果可以被后续的操作获取。 对一个锁的解锁操作happens-before（先行发生）于后面对同一个锁的加锁操作。 对于一个volatile变量的写操作先行发生与后面对这个变量的读操作。 如果操作A先行发生与操作B，操作B先行发生于操作C，那么操作A先行发生与操作C。 Thread对象的start()方法先行发生于此线程中的任意操作。 对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生。 线程中所有操作都先行发生于对此线程的终止检测，可以通过Thread.isAlive()方法检测线程是否已经终止执行。 一个对象的初始化完成（构造方法执行结束）先行发生于它的finalize()方法的开始，即对象没有完成初始化之前，是不能调用finalized()方法的。
private int value = 0 ;
public void setValue ( int value) {
this . value = value;
}
public int getValue ( ) {
return value;
}
可以用来修饰成员变量和静态成员变量，保证线程间变量的可见性，但不能保证原子性。 线程对共享变量进行修改后，要立刻写回主内存中。线程操作volatile变量都是直接操作主存。 线程对共享变量读取的时候，必须到主内存中读取变量的最新值，而不是缓存中。
@Slf4j
public class VolatileTest1 {
static boolean status = false ;
public static void main ( String [ ] args) {
log. info ( "线程{}开始执行，status = {}" , Thread . currentThread ( ) . getName ( ) , status) ;
new Thread ( ( ) -> {
try {
Thread . sleep ( 3000 ) ;
} catch ( InterruptedException e) {
e. printStackTrace ( ) ;
}
status = true ;
log. info ( "线程{}修改status，status = {}" , Thread . currentThread ( ) . getName ( ) , status) ;
} , "A" ) . start ( ) ;
while ( true ) {
if ( status) {
break ;
}
}
log. info ( "线程{}，status = {}" , Thread . currentThread ( ) . getName ( ) , status) ;
}
}
synchronized、Lock）
@Slf4j
public class VolatileTest2 {
volatile static boolean status = false ;
public static void main ( String [ ] args) {
log. info ( "线程{}开始执行，status = {}" , Thread . currentThread ( ) . getName ( ) , status) ;
new Thread ( ( ) -> {
try {
Thread . sleep ( 3000 ) ;
} catch ( InterruptedException e) {
e. printStackTrace ( ) ;
}
status = true ;
log. info ( "线程{}修改status，status = {}" , Thread . currentThread ( ) . getName ( ) , status) ;
} , "A" ) . start ( ) ;
while ( true ) {
if ( status) {
break ;
}
}
log. info ( "线程{}，status = {}" , Thread . currentThread ( ) . getName ( ) , status) ;
}
}
@Slf4j
public class VolatileTest3 {
final static Object obj = new Object ( ) ;
static boolean status = false ;
public static void main ( String [ ] args) {
log. info ( "线程{}开始执行，status = {}" , Thread . currentThread ( ) . getName ( ) , status) ;
new Thread ( ( ) -> {
synchronized ( obj) {
try {
Thread . sleep ( 3000 ) ;
} catch ( InterruptedException e) {
e. printStackTrace ( ) ;
}
status = true ;
log. info ( "线程{}修改status，status = {}" , Thread . currentThread ( ) . getName ( ) , status) ;
}
} , "A" ) . start ( ) ;
while ( true ) {
synchronized ( obj) {
if ( status) {
break ;
}
}
}
log. info ( "线程{}，status = {}" , Thread . currentThread ( ) . getName ( ) , status) ;
}
}
JAVA内存模型（JMM）要求保证原子性，但是volatile不能保证原子性。
public class VolatileTest4 {
volatile int num = 0 ;
public static void main ( String [ ] args) throws InterruptedException {
VolatileTest4 test4 = new VolatileTest4 ( ) ;
for ( int i = 0 ; i < 10 ; i++ ) {
new Thread ( ( ) -> {
for ( int j = 1 ; j <= 1000 ; j++ ) {
test4. addNum ( ) ;
}
} , String . valueOf ( i) ) . start ( ) ;
}
while ( Thread . activeCount ( ) > 2 ) {
Thread . yield ( ) ;
}
System . out. println ( test4. num) ;
}
public void addNum ( ) {
num ++ ;
}
}
volatile修饰的变量不能保证原子性。
synchronized，假设有2个线程同时通过getfield指令拿到主内存中num的值，然后2个线程在各自的工作内存中进行加1操作，因为可见性，需要写回主内存，但是线程1在写入的时候，线程2也同时写入，导致线程1的写入操作被挂起，这样造成了线程2写入后线程1覆盖了线程2的值，造成了数据丢失问题，也就让最终的结果少于10000。
synchronized、Lock）：由于synchronized和Lock能够保证任一时刻只有一个线程执行该代码块，那么自然就不存在原子性问题了，从而保证了原子性，同时也保证了共享变量的可见性。但是属于重量级操作，性能相对更低。AtomicInteger）
public class VolatileTest5 {
volatile int num = 0 ;
AtomicInteger atomicInteger = new AtomicInteger ( ) ;
public static void main ( String [ ] args) throws InterruptedException {
VolatileTest5 test4 = new VolatileTest5 ( ) ;
for ( int i = 0 ; i < 10 ; i++ ) {
new Thread ( ( ) -> {
for ( int j = 1 ; j <= 1000 ; j++ ) {
test4. addNum ( ) ;
test4. addAtomicInteger ( ) ;
}
} , String . valueOf ( i) ) . start ( ) ;
}
while ( Thread . activeCount ( ) > 2 ) {
Thread . yield ( ) ;
}
System . out. println ( "int type, finally number value：" + test4. num) ;
System . out. println ( "atomicInteger type, finally number value：" + test4. atomicInteger) ;
}
public synchronized void addNum ( ) {
num ++ ;
}
public void addAtomicInteger ( ) {
atomicInteger. getAndIncrement ( ) ;
}
}
编译器优化重排序：编译器在不改变单线程程序语义的前提下，可以重新安排语句的执行顺序。 指令级并行重排序：现代处理器采用了指令级并行技术来将多条指令重叠执行。如果不存在数据依赖性，处理器可以改变语句对应机器指令的执行顺序。 内存系统重排序：由于处理器使用缓存和读/写缓冲区，这使得加载和存储操作看上去可能是在乱序执行的。
通过内存屏障指令来禁止特定类型的处理器重排序（不是所有的处理器重排序都要禁止）。 处理器在进行重排序时必须要考虑指令之间的数据依赖性。
public void method01 ( ) {
int a = 1 ;
int b = 2 ;
a = a + 3 ;
b = a * a;
}
public class VolatileTest6 {
int a = 0 ;
boolean flag = false ;
public void method1 ( ) {
a = 2 ;
flag = true ;
}
public void method2 ( ) {
if ( flag) {
a = a + 5 ;
System . out. println ( "a的值为：" + a) ;
} else {
a = 1 ;
System . out. println ( "a的值为：" + a) ;
}
}
}
总结：这种现象叫做指令重排。在多线程环境中线程交替执行，由于编译器优化重排的存在，两个线程中使用的变量能否保证一致性是无法确定的，结果无法预测。
使用volatile关键字修饰变量，可以禁止指令重排序。synchronized、Lock）：synchronized和Lock保证每个时刻是有一个线程执行同步代码，相当于是让线程顺序执行同步代码，自然就保证了有序性。
public class VolatileTest6 {
int a = 0 ;
volatile boolean flag = false ;
public void method1 ( ) {
a = 2 ;
flag = true ;
}
public void method2 ( ) {
if ( flag) {
a = a + 5 ;
System . out. println ( "a的值为：" + a) ;
} else {
a = 1 ;
System . out. println ( "a的值为：" + a) ;
}
}
}
要求Java编译器在生成JVM指令时插入特定的内存屏障指令，通过内存屏障指令，volatile实现了JMM中的可见性和有序性（禁重排）。 内存屏障之前的所有写操作都要写回主内存。 内存屏障之后的所有读操作都能获得内存屏障之前的所有写操作的最新结果（实现了可见性） 保证特定操作的执行顺序。 保证共享变量的内存可见性（利用该特性实现volatile的内存可见性）。
写屏障（Store Memory Barrier）： 读屏障（Load Memory Barrier）：
屏障类型 指令示例 说明 LoadLoadLoad1;LoadLoad;Load2 保证Load1的读取操作在Load2及后续读取操作之前执行 StoreStoreStore1;StoreStore;Store2 在Store2及后面的写操作执行前，保证Store1的写操作已刷新到主内存 LoadStoreLoad1;LoadStore;Store2 在Store2及后面的写操作执行前，保证Load1的读操作已结束 StoreLoadStore1;StoreLoad;Load2 保证Store1的写操作已刷新到主内存之后，Load2及其后面的读操作才能执行
第一个操作 第二个操作普通读写 第二个操作volatile读 第二个操作volatile写 普通读写可以重排 可以重排 不可以重排 volatile读不可以重排 不可以重排 不可以重排 volatile写可以重排 不可以重排 不可以重排
在每个volatile读操作的后面插入一个LoadLoad屏障。 在每个volatile读操作的后面插入一个LoadStore屏障。 LoadLoad屏障：用来禁止处理器把上面的volatile读与下面的普通读重排序。 LoadStore屏障：用来禁止处理器把上面的volatile读与下面的普通写重排序。
在每个volatile写操作的前面插入一个StoreStore屏障。 在每个volatile写操作的后面插入一个StoreLoad屏障。 StoreStore屏障：可以保证在volatile写之前，其前面的所有普通写操作已经刷新到主内存。 StoreLoad屏障：作用是避免volatile写与后面可能有的volatile读/写操作重排序。
对StoreLoad屏障的解释：因为编译器常常无法准确判断在一个volatile写的后面是否需要插入一个StoreLoad屏障（比如，一个volatile写之后方法立即return）。为了保证能正确实现volatile的内存语义，JMM在采取了保守策略： 一个写线程写volatile变量，多个读线程读同一个volatile变量。当读线程的数量大大超过写线程时，选择在volatile写之后插入StoreLoad屏障将带来可观的执行效率的提升（也就是说如果在读之前加StoreLoad屏障，就要加得非常多，降低程序效率）。
public class Singleton {
private static Singleton instance;
private Singleton ( ) { }
public static Singleton getInstance ( ) {
if ( instance == null ) {
synchronized ( Singleton . class ) {
if ( instance == null ) {
instance = new Singleton ( ) ;
}
}
}
return instance;
}
}
因此需要加入volatile可以禁止指令重排 instance = new Singleton()可以分为以下步骤（伪代码） 加入双端检锁机制（也即加入同步代码块），并在需要单例的这个对象前面加入volatile来禁止指令重排。
public class Singleton {
private static volatile Singleton instance;
private Singleton ( ) { }
public static Singleton getInstance ( ) {
if ( instance == null ) {
synchronized ( Singleton . class ) {
if ( instance == null ) {
instance = new Singleton ( ) ;
}
}
}
return instance;
}
}
223
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
