目录

一、一个问题引发的思考

二、什么是可见性

2.1 硬件层面

2.1.1 CPU高速缓存

2.1.2 总线锁&缓存锁&＃xff0c;和缓存一致性

2.1.3 既然cpu有机制可以达成缓存一致性&＃xff0c;为什么还是会有可见性问题&＃xff1f;

三、引出了MESI的一个优化&＃xff08;x86结构&＃xff09;

3.1 优化前cpu修改share状态缓存示意图&＃xff1a;

3.2 Store Bufferes

3.2.1 指令重排序的过程

3.3 通过内存屏障禁止了指令重排序

四、软件层面

4.1 JMM

五、Volatile的原理

5.1 通过javap -v VolatileDemo.class查看字节指令

5.2java定义的内存屏障指令&＃xff1a;

5.3 volatile解决可见性问题

5.4 单例模式中的可见性问题(DCL问题——双重检查锁)

六、Happens-Before模型

 6.1 程序顺序规则&＃xff08;as-if-serial语义&＃xff09;

6.2 传递性规则

6.3 volatile变量规则

6.4 监视器锁规则

6.5 start规则(线程启动规则)

6.6 Join规则(线程终结规则)

参考博客

一、一个问题引发的思考

public class VolatileDemo {public static boolean flag &＃61; true;public static void main(String[] args) throws InterruptedException {Thread thread &＃61; new Thread(()->{int i &＃61; 0;while (flag){i&＃43;&＃43;;}});thread.start();Thread.sleep(1000);flag &＃61; false;}
}


执行上面一段代码&＃xff0c;会发现虽然把flag变量改成了false&＃xff0c;但是线程并没有停止&＃xff0c;貌似main线程更改了值&＃xff0c;对于thread线程来说并不知道&＃xff0c;这就是我们常说的线程中的可见性问题&＃xff0c;也是引起线程安全问题的根本原因。

那怎么解决这个问题呢&＃xff1f;非常简单&＃xff0c;java中最常见的就是通过volatile关键字解决&＃xff0c;如下代码&＃xff1a;

public class VolatileDemo {// 添加volatile关键字&＃xff0c;解决可见性问题public volatile static boolean flag &＃61; true;public static void main(String[] args) throws InterruptedException {Thread thread &＃61; new Thread(()->{int i &＃61; 0;while (flag){i&＃43;&＃43;;}});thread.start();Thread.sleep(1000);flag &＃61; false;}
}

二、什么是可见性

在单线程的环境下&＃xff0c;如果向一个变量先写入一个值&＃xff0c;然后在没有写干涉的情况下读取这个变量的值&＃xff0c;那这个时候读取到的这个变量的值应该是之前写入的那个值。这本来是一个很正常的事情。

但是在多线程环境下&＃xff0c;读和写发生在不同的线程中的时候&＃xff0c;可能会出现&＃xff1a;读线程不能及时的读取到其他线程写入的最新的值。这就是所谓的可见性问题。

2.1 硬件层面

CPU/内存/IO设备&＃xff0c;由于运行速度的差异&＃xff0c;所以对cpu有一定的优化
主要体现在三个方面&＃xff1a;

1. CPU层面增加了高速缓存
2. 操作系统&＃xff0c;进程、线程、| CPU时间片来切换
3. 编译器的优化 &＃xff0c;更合理的利用CPU的高速缓存

2.1.1 CPU高速缓存

因为高速缓存的存在&＃xff0c;会导致一个缓存一致性问题。 下图是CPU高速缓存的一个模型图&＃xff0c;我们可以分析出&＃xff0c;ThreadA线程不能及时读取到ThreadB线程更改的值&＃xff08;数据不可见性&＃xff09;&＃xff0c;从而导致缓存数据不一致。

2.1.2 总线锁&缓存锁&＃xff0c;和缓存一致性

总线锁

L1是一级缓存&＃xff0c;L1d是数据缓存、L1i是指令缓存
L2是二级缓存&＃xff0c;大小比一级缓存大一点
L3是三级缓存&＃xff0c;L3缓存主要目的是为了敬意不降低内存操作的延迟问题 

总线锁&＃xff1a;简单来说就是&＃xff0c;在多cpu下&＃xff0c;当其中一个处理器要对共享内存进行操作的时候&＃xff0c;在总线上发出一个LOCK#信号&＃xff0c;这个信号使得其他处理器无法通过总线来访问到共享内存中的数据&＃xff0c;总线锁定把CPU和内存之间的通信锁住了&＃xff0c;这使得锁定期间&＃xff0c;其他处理器不能操作其他内存地址的数据&＃xff0c;所以总线锁定的开销比较大&＃xff0c;这种机制显然是不合适的 。

如何优化呢&＃xff1f;最好的方法就是控制锁的保护粒度&＃xff0c;我们只需要保证对于被多个CPU缓存的同一份数据是一致的就行。在P6架构的CPU后&＃xff0c;引入了缓存锁&＃xff0c;如果当前数据已经被CPU缓存了&＃xff0c;并且是要协会到主内存中的&＃xff0c;就可以采用缓存锁来解决问题。

所谓的缓存锁&＃xff0c;就是指内存区域如果被缓存在处理器的缓存行中&＃xff0c;并且在Lock期间被锁定&＃xff0c;那么当它执行锁操作回写到内存时&＃xff0c;不再总线上加锁&＃xff0c;而是修改内部的内存地址&＃xff0c;基于缓存一致性协议来保证操作的原子性。

总线锁和缓存锁怎么选择&＃xff0c;取决于很多因素&＃xff0c;比如CPU是否支持、当前数据是否存在于缓存行以及存在无法缓存的数据时&＃xff08;比较大或者快约多个缓存行的数据&＃xff0c;必然还是会使用总线锁。&＃xff09;

缓存锁

为了达到数据访问的一致&＃xff0c;需要各个处理器在访问缓存时遵循一些协议&＃xff0c;在读写时根据协议来操作&＃xff0c;常见的协议有MSI&＃xff0c;MESI&＃xff0c;MOSI等。最常见的就是MESI协议。接下来给大家简单讲解一下MESI表示缓存行的四种状态&＃xff0c;分别是&＃xff1a;

1. M(Modify) 表示共享数据只缓存在当前CPU缓存中&＃xff0c;并且是被修改状态&＃xff0c;也就是缓存的数据和主内存中的数据不一致
2. E(Exclusive) 表示缓存的独占状态&＃xff0c;数据只缓存在当前CPU缓存中&＃xff0c;并且没有被修改
3. S(Shared) 表示数据可能被多个CPU缓存&＃xff0c;并且各个缓存中的数据和主内存数据一致
4. I(Invalid) 表示缓存已经失效

当cpu运行的时候&＃xff0c;都会加载shop的值。以下是缓存各种状态示意图&＃xff1a;

1.Exclusive——独占&＃xff1a;

 当stop值只存在某一个CUP0的缓存行中&＃xff0c;这种状态叫缓存的独占状态。

 2.Shared——共享

 当stop值存在与多个cup中&＃xff0c;叫共享状态。

3.Modify——修改

 当stop值只存在CPU0的缓存中时&＃xff0c;若修改stop值&＃xff0c;会从独占状态变为修改状态。

4.Invalid——失效

当stop值同时存在CPU0和CPU1的的缓存中时&＃xff0c;若CPU0修改stop值&＃xff0c;此时会从CPU1的缓存行会变为失效状态。
此后CPU1会再次从主存中加载stop值。

缓存一致性

cpu就是通过缓存一致性协议或总线锁机制去达成缓存的一致性。

2.1.3 既然cpu有机制可以达成缓存一致性&＃xff0c;为什么还是会有可见性问题&＃xff1f;

以下文字摘自于其他博客&＃xff0c;以供参考&＃xff1a;

既然CPU有缓存一致性协议&＃xff08;MESI&＃xff09;&＃xff0c;为什么JMM还需要volatile关键字&＃xff1f;

volatile是java语言层面给出的保证&＃xff0c;MSEI协议是多核cpu保证cache一致性的一种方法&＃xff0c;中间隔的还很远&＃xff0c;我们可以先来做几个假设&＃xff1a;

1.回到远古时候&＃xff0c;那个时候cpu只有单核&＃xff0c;或者是多核但是保证sequence consistency&＃xff0c;当然也无所谓有没有MESI协议了。那这个时候&＃xff0c;我们需要java语言层面的volatile的支持吗&＃xff1f;

当然是需要的&＃xff0c;因为在语言层面编译器和虚拟机为了做性能优化&＃xff0c;可能会存在指令重排的可能&＃xff0c;而volatile给我们提供了一种能力&＃xff0c;我们可以告诉编译器&＃xff0c;什么可以重排&＃xff0c;什么不可以。

2.那好&＃xff0c;假设更进一步&＃xff0c;假设java语言层面不会对指令做任何的优化重排&＃xff0c;那在多核cpu的场景下&＃xff0c;我们还需要volatile关键字吗&＃xff1f;

答案仍然是需要的。因为 MESI只是保证了多核cpu的独占cache之间的一致性&＃xff0c;但是cpu的并不是直接把数据写入L1 cache的&＃xff0c;中间还可能有store buffer。有些arm和power架构的cpu还可能有load buffer或者invalid queue等等。因此&＃xff0c;有MESI协议远远不够。

3.再接着&＃xff0c;让我们再做一个更大胆的假设。假设cpu中这类store buffer/invalid queue等等都不存在了&＃xff0c;cpu是数据是直接写入cache的&＃xff0c;读取也是直接从cache读的&＃xff0c;那还需要volatile关键字吗&＃xff1f;
你猜的没错&＃xff0c;还需要的。原因就在这个“一致性”上。consistency和coherence都可以被翻译为一致性&＃xff0c;但是MSEI协议这里保证的仅仅coherence而不是consistency。那consistency和cohence有什么区别呢&＃xff1f;

下面取自wiki的一段话&＃xff1a;
Coherence deals with maintaining a global order in which writes to a single location or single variable are seen by all processors. Consistency deals with the ordering of operations to multiple locations with respect to all processors.
因此&＃xff0c;MESI协议最多只是保证了对于一个变量&＃xff0c;在多个核上的读写顺序&＃xff0c;对于多个变量而言是没有任何保证的。很遗憾&＃xff0c;还是需要volatile&＃xff5e;&＃xff5e;

4.好的&＃xff0c;到了现在这步&＃xff0c;我们再来做最后一个假设&＃xff0c;假设cpu写cache都是按照指令顺序fifo写的&＃xff0c;那现在可以抛弃volatile了吧&＃xff1f;你觉得呢&＃xff1f;

那肯定不行啊&＃xff01;因为对于arm和power这个weak consistency的架构的cpu来说&＃xff0c;它们只会保证指令之间有比如控制依赖&＃xff0c;数据依赖&＃xff0c;地址依赖等等依赖关系的指令间提交的先后顺序&＃xff0c;而对于完全没有依赖关系的指令&＃xff0c;比如x&＃61;1;y&＃61;2&＃xff0c;它们是不会保证执行提交的顺序的&＃xff0c;除非你使用了volatile&＃xff0c;java把volatile编译成arm和power能够识别的barrier指令&＃xff0c;这个时候才是按顺序的。
最后总结&＃xff0c;答案就是&＃xff1a;还需要&＃xff5e;&＃xff5e;

三、引出了MESI的一个优化&＃xff08;x86结构&＃xff09;

3.1 优化前cpu修改share状态缓存示意图&＃xff1a;

1. cpu0修改值&＃xff0c;要执行write操作&＃xff0c;写入之前要保持强一致&＃xff0c;会发送invalidate到cup1&＃xff0c;这个通知是一个失效通知&＃xff0c;让其他缓存失效
2. cpu1收到invalidate通知后&＃xff0c;会让该值缓存失效&＃xff0c;并通过ACK机制发送回执给cpu0
3. 在这个通信过程中&＃xff0c;cpu0会一直处于阻塞状态。在收到ACK回执后&＃xff0c;再写入到内存

以上过程&＃xff0c;阻塞时间会很短&＃xff0c;但依然会造成cpu资源的浪费。所以cpu引入了Store Bufferes。

3.2 Store Bufferes

Store Bufferes是一个写的缓冲&＃xff0c;对于上述描述的情况&＃xff0c;CPU0可以先把写入的操作先存储到StoreBufferes中&＃xff0c;Store Bufferes中的指令再按照缓存一致性协议去发起其他CPU缓存行的失效。而同步来说CPU0可以不用等到Acknowledgement&＃xff0c;继续往下执行其他指令&＃xff0c;直到收到CPU0收到Acknowledgement再更新到缓存&＃xff0c;再从缓存同步到主内存。

3.2.1 指令重排序的过程

我们来关注下面这段代码&＃xff0c;假设分别有两个线程&＃xff0c;分别执行executeToCPU0和executeToCPU1&＃xff0c;分别由两个不同的CPU来执行。
引入Store Bufferes之后&＃xff0c;就可能出现 b&＃61;&＃61;1返回true &＃xff0c;但是assert(a&＃61;&＃61;1)返回false。很多同学肯定会表示不理解&＃xff0c;这种情况怎么可能成立&＃xff1f;那接下来我们去分析一下。

/*伪代码*/
executeToCPU0(){a&＃61;1;b&＃61;1;
}executeToCPU1(){while(b&＃61;&＃61;1){assert(a&＃61;&＃61;1);}
}


上述代码图解&＃xff1a;

这就是cpu层面的指令重排序。

3.3 通过内存屏障禁止了指令重排序

上面的Store Bufferes 是为了提高cpu的利用率&＃xff0c;但这样也带来了指令重排序。为了解决这个问题&＃xff0c;cpu也提供了内存屏障的指令。

X86的memory barrier指令包括lfence(读屏障) sfence(写屏障) mfence(全屏障)&＃xff1a;

1. Store Memory Barrier(写屏障) &＃xff0c;告诉处理器在写屏障之前的所有已经存储在存储缓存(storebufferes)中的数据同步到主内存&＃xff0c;简单来说就是使得写屏障之前的指令的结果对屏障之后的读或者写是可见的
2. Load Memory Barrier(读屏障) &＃xff0c;处理器在读屏障之后的读操作,都在读屏障之后执行。配合写屏障&＃xff0c;使得写屏障之前的内存更新对于读屏障之后的读操作是可见的
3. Full Memory Barrier(全屏障) &＃xff0c;确保屏障前的内存读写操作的结果提交到内存之后&＃xff0c;再执行屏障后的读写操作

 上述加屏障后的伪代码&＃xff1a;

volatile int a&＃61;0;
executeToCpu0(){a&＃61;1;//storeMemoryBarrier()写屏障&＃xff0c;写入到内存b&＃61;1;// CPU层面的重排序//b&＃61;1;//a&＃61;1;
} executeToCpu1(){while(b&＃61;&＃61;1){ //trueloadMemoryBarrier(); //读屏障assert(a&＃61;&＃61;1) //false}
}

 volatile会自动加写屏障和读屏障。

四、软件层面

上述我们说得都是硬件层面解决可见性问题&＃xff0c;并且是基于x86架构&＃xff0c;但是我们的java代码是会运行在不同的cpu架构中的。
由此引出了java内存模型&＃xff0c;它与jvm运行数据区不是一个概念。

4.1 JMM

 编译器优化重排序伪代码&＃xff1a;

int a&＃61;0;
executeToCpu0(){a&＃61;1;b&＃61;1;// 编译器层面也会重排序//b&＃61;1;//a&＃61;1;
} executeToCpu1(){while(b&＃61;&＃61;1){ //trueassert(a&＃61;&＃61;1) //false}
}

其实通过前面的内容分析我们发现&＃xff0c;导致可见性问题有两个因素&＃xff0c;一个是高速缓存导致的可见性问题&＃xff0c;另一个是指令重排序。那JMM是如何解决可见性和有序性问题的呢&＃xff1f;

其实前面在分析硬件层面的内容时&＃xff0c;已经提到过了&＃xff0c;对于缓存一致性问题&＃xff0c;有总线锁和缓存锁&＃xff0c;缓存锁是基于MESI协议。而对于指令重排序&＃xff0c;硬件层面提供了内存屏障指令。而JMM在这个基础上提供了volatile、final等关键字&＃xff0c;使得开发者可以在合适的时候增加相应相应的关键字来禁止高速缓存和禁止指令重排序来解决可见性和有序性问题。

五、Volatile的原理

5.1 通过javap -v VolatileDemo.class查看字节指令

public static volatile boolean stop;
descriptor: Z
flags: ACC_PUBLIC, ACC_STATIC, ACC_VOLATILE

 volatile源码多了一个ACC_VOLATILE

5.2java定义的内存屏障指令&＃xff1a;

5.3 volatile解决可见性问题

 一句话来说就是&＃xff1a;提供防止指令重排序的机制&＃xff0c;和内存屏障机制取解决可见性问题。

5.4 单例模式中的可见性问题(DCL问题——双重检查锁)

public class DoubleCheckSingleton {private static DoubleCheckSingleton instance &＃61; null; public static DoubleCheckSingleton getInstance(){if(instance&＃61;&＃61;null){synchronized (DoubleCheckSingleton.class) {if (instance &＃61;&＃61; null) {instance &＃61; new DoubleCheckSingleton();//这里由于out-of-order}}}return instance;}
}

上面的instance没有用volatile修饰&＃xff0c;会有可见性问题&＃xff1a;

这里说的是语句instance &＃61; new DoubleCheckSingleton()不是一个原子操作
instance &＃61; new DoubleCheckSingleton();//这里由于out-of-order 无序操作

那么问题就来了&＃xff1a;必然会做这么些事情

1. 给DoubleCheckSingleton分配内存
2. 初始化DoubleCheckSingleton实例
3. 将instance对象指向分配的内存空间&＃xff08;instance为null了&＃xff09;

而在1&＃xff0c;2&＃xff0c;3中&＃xff0c;执行顺序可能出现2&＃xff0c;3或者3&＃xff0c;2这种情况&＃xff0c;如果是3&＃xff0c;2 自然另一个线程拿到的可能是未初始化好的DoubleCheckSingleton

JDK1.5后可改为&＃xff0c;private volatile static DoubleCheckSingleton instance &＃61; null 每次都从主内存读取instance。

六、Happens-Before模型

除了显示引用volatile关键字能够保证可见性以外&＃xff0c;在Java中&＃xff0c;还有很多的可见性保障的规则。
从JDK1.5开始&＃xff0c;引入了一个happens-before的概念来阐述多个线程操作共享变量的可见性问题。
所以我们可以认为在JMM中&＃xff1a;

如果一个操作执行的结果需要对另一个操作可见&＃xff0c;那么这两个操作必须要存在happens-before关系。这两个操作可以是同一个线程&＃xff0c;也可以是不同的线程。

• 程序顺序规则&＃xff08;as-if-serial语义&＃xff09;
• 传递性规则
• volatile变量规则
• 监视器锁规则
• start规则
• join规则
   

 6.1 程序顺序规则&＃xff08;as-if-serial语义&＃xff09;

• 不能改变程序的执行结果(在单线程环境下&＃xff0c;执行的结果不变
• 依赖问题&＃xff0c; 如果两个指令存在依赖关系&＃xff0c;是不允许重排序

int a&＃61;0;
int b&＃61;0;
void test(){int a&＃61;1; aint b&＃61;1; b//int b&＃61;1;//int a&＃61;1;int c&＃61;a*b; c
}

a happens -before b ; b happens before c

6.2 传递性规则

如果操作A先行发生于操作B&＃xff0c;而操作B又先行发生于操作C&＃xff0c;则可以得出操作A先行发生于操作C&＃xff1b;
a happens-before b , b happens- before c, a happens-before c

6.3 volatile变量规则

这是一条比较重要的规则&＃xff0c;它标志着volatile保证了线程可见性。通俗点讲就是如果一个线程先去写一个volatile变量&＃xff0c;然后一个线程去读这个变量&＃xff0c;那么这个写操作一定是happens-before读操作的。

内存屏障机制来防止指令重排

public class VolatileExample{int a&＃61;0;volatile boolean flag&＃61;false;public void writer(){a&＃61;1; //1flag&＃61;true; //修改 2}public void reader(){if(flag){ //true 3int i&＃61;a; //1 4}}
}

1 happens-before 2 是否成立&＃xff1f; 是 -> ?
3 happens-before 4 是否成立? 是
2 happens -before 3 ->volatile规则
1 happens-before 4 ; i&＃61;1成立

6.4 监视器锁规则

一个unLock操作先行发生于后面对同一个锁lock操作&＃xff1b;(synchronized)

int x&＃61;10;
synchronized(this){//后续线程读取到的x的值一定12if(x<12){x&＃61;12;}
}
x&＃61;12;

6.5 start规则(线程启动规则)

假定线程A在执行过程中&＃xff0c;通过执行ThreadB.start()来启动线程B&＃xff0c;那么线程A对共享变量的修改在接下来线程B开始执行后确保对线程B可见。

public class StartDemo{int x&＃61;0;Thread t1&＃61;new Thread(()->{//读取x的值 一定是20if(x&＃61;&＃61;20){}});x&＃61;20;t1.start();
}

6.6 Join规则(线程终结规则)

假定线程A在执行的过程中&＃xff0c;通过制定ThreadB.join()等待线程B终止&＃xff0c;那么线程B在终止之前对共享变量的修改在线程A等待返回后可见。

public class Test{int x&＃61;0;Thread t1&＃61;new Thread(()->{x&＃61;200;});t1.start();t1.join(); //保证结果的可见性。//在此处读取到的x的值一定是200.
}

兴趣拓展&＃xff1a;final关键字提供了内存屏障的规则

参考博客

CPU有缓存一致性协议(MESI)&＃xff0c;为何还需要volatile