JVM级别内存屏障如何禁止指令重排序的

承接上文证明CPU指令是乱序执行的

当多个cpu访问同一份数据的时候怎么保证数据的一致性&＃xff1f;

在最底层级别的控制有好多种&＃xff1a;

第一种叫关中断&＃xff0c;就是访问任何数据的时候必须有一个中断信号量的存在。很多传统的cpu就是靠它实现的&＃xff0c;从内存读东西的时候实际上是通过中断响应去读的&＃xff0c;比如访问这块内存的时候把中断给关了&＃xff0c;任何读也好&＃xff0c;写也好&＃xff0c;io操作中断全不响应&＃xff0c;就没有人能打断你&＃xff0c;因为把能打断我的所有的指令都给关了&＃xff0c;只要没人打断你&＃xff0c;就一定能保证数据的一致性&＃xff0c;这也涉及到芯片中断的内容&＃xff1b;

第二种就是CPU缓存一致性&＃xff1b;

第三种就是系统屏障&＃xff1a;cpu访问内存数据&＃xff0c;把数据线锁住&＃xff0c;只允许一颗cpu传数据&＃xff0c;其他cpu就不能传&＃xff0c;同一时刻只有一个cpu可以访问这个数据&＃xff0c;

怎么防止指令重排序&＃xff1f;

第一种情况是禁止编译器乱序&＃xff0c;有的代码在编译的过程中就直接乱序了&＃xff1b;

第二种是使用内存屏障阻止指令乱序执行。

随便写2个指令&＃xff0c;在编译器编译的时候就可能会产生乱序&＃xff0c;只要前后没有依赖关系就有可能产生&＃xff0c;这是在编译阶段&＃xff1b;有前后关联关系的是不能够随便换顺序的&＃xff0c;比如x&＃61;1和y&＃61;x&＃43;1&＃xff1b;没有关联关系的话&＃xff0c;就有可能换顺序&＃xff0c;比如x&＃61;1和y&＃61;2。

c语言的volatile&＃xff0c;底层是通过这条指令禁止编译器将前后2个指令换顺序执行的。

a&＃61;1和b&＃61;d这两个指令在编译器编译的时候不能换顺序执行&＃xff0c;这种被称为内存屏障。

volatile是指令级别的屏障 &＃xff0c;它也是一种特殊的指令&＃xff1b;

不同的cpu&＃xff0c;内存屏障的指令是不一样的&＃xff0c;因特尔的内存屏障有lfence(读屏障)、sfence(写屏障)、mfence(不管读还是写都不能越过)。

内存屏障指令有很多种&＃xff0c;不同的cpu是不同的指令&＃xff0c;使用内存屏障来阻止指令的乱序执行。

除了lfence、mfence、sfence这些内存屏障指令之外的其他有哪些内存屏障?

在jvm中也存在内存屏障&＃xff0c;jvm不是一台实体的机器&＃xff0c;不像intel一样具备一个物理的cpu&＃xff0c;jvm只是一个逻辑概念&＃xff0c;jvm内存屏障一共规定了4类&＃xff0c;所有实现jvm规范的虚拟机必须实现四个屏障&＃xff1a;

读读指令中间加一个LoadLoad(LL屏障)&＃xff0c;读读就不能换顺序&＃xff1b;

写写指令中间加一个SS屏障&＃xff0c;写写就不能换顺序&＃xff1b;

读写指令中间加一个LS屏障&＃xff0c;读写指令不能换顺序。

规定了相邻的2个操作不能换顺序&＃xff0c;就相当于一个屏障。

在cpu的基础之上构建了操作系统os来管理cpu&＃xff1b;

jvm在os系统看来只是一个很普通的程序而已&＃xff0c;jvm在自己的程序里规定了好多屏障&＃xff0c;最终这些屏障的实现也得靠cpu和os提供的能力。

不能将jvm级别的内存屏障和系统级别的内存屏障混在一起。

jvm是c&＃43;&＃43;写的&＃xff0c;在里面规定了自己写的内存屏障&＃xff0c;jvm想实现内存屏障最终还得映射成cpu的内存屏障。

volatile的实现细节

volatile两大作用&＃xff1a;

第一个是保障可见性&＃xff1a;一个cpu改了的内容另外一个cpu马上可见&＃xff1b;

第二个作用是禁止指令重排序&＃xff1a;比如new对象时候的三个指令不会换顺序执行。

volatile其实是一个普通的关键字&＃xff0c;无非是修饰了某块内存和某块变量。

在jvm层做一个特殊的操作&＃xff0c;jvm规定volatile所修饰的变量&＃xff0c;对这块内存做写操作的时候&＃xff0c;在它前面必须加一个屏障SS&＃xff0c;后面加个屏障叫SL&＃xff0c;前面的所有写操作必须先执行完&＃xff0c;然后再往里面写&＃xff0c;必须等我写完&＃xff0c;别人才能读。

必须等我读完别人才能读&＃xff0c;必须等我读完别人才能写。

volatile修饰的内存&＃xff0c;对它的任何访问全都换不了顺序&＃xff0c;

这个只是jvm自己规定的&＃xff0c;最终一定要体现在cpu级别的&＃xff0c;cpu级别怎么实现的&＃xff1f;

不同的jvm有不同的实现&＃xff0c;最流行的jvm hotspot oracle所提供的&＃xff0c;hotspot volatile底层到底怎么实现的?

java写的volatile&＃xff0c;jvm编译执行&＃xff0c;java是解释执行的&＃xff0c;所以要想了解volatile怎么实现的&＃xff0c;得去读hotspot解释器的代码&＃xff0c;看是怎么解释完成的&＃xff1f;

二进制码解释器的实现类是bytecodeInterpreter.cpp&＃xff0c;可以看到是怎么解释运行volatile的&＃xff0c;

可以看到最终的实现是一条汇编指令&＃xff0c;不是lfence 、mfence、sfence。

两条指令可以乱序执行&＃xff0c;多线程的情况会读到中间状态的各种各样的情形&＃xff0c;所以必须得实现一种机制&＃xff0c;不让两条指令乱序执行&＃xff0c;最底层cpu级别实现了指令级别的机制&＃xff0c;编译器级别也实现了禁止编译器优化的指令&＃xff0c;jvm级别也实现了自己的逻辑操作&＃xff0c;但是jvm级别的指令最终要落到cpu级别&＃xff0c;cpu级别最终是怎么落上去的&＃xff1f;

is_MP方法是判断是否为多个处理器&＃xff08;或多个cpu&＃xff09;&＃xff0c;如果是的话就执行lock addl&＃xff0c;l是lense的意思&＃xff0c;rsp或esp是寄存器指令 &＃xff0c;把某个寄存器的值加上一个0&＃xff0c;为什么lock指令可以实现禁止指令重排序&＃xff1f;

每种cpu最终的对于屏障的实现应该对应特定的指令&＃xff0c;比如lfense、mfense指令&＃xff0c;但是hotspot偷了个懒&＃xff0c;cpu通过执行lock指令来实现&＃xff1a;当cpu或线程访问某个内存的时候&＃xff0c;会锁住总线&＃xff0c;不允许其他cpu去读或去写&＃xff0c;必须等我读完写完&＃xff0c;其他才可以继续&＃xff0c;这样就不会乱序了。

lock主要用于在多处理器中执行指令时对共享内存的独占使用&＃xff0c;将当前处理器对应的缓存刷新到内存并使其他处理器对应的缓存失效&＃xff0c;其他处理器得重新读&＃xff0c;另外还提供了禁止指令重排序即无法越过内存屏障的作用。

凡是在lock前后加任何指令都不能越过&＃xff0c;因为它是一个全屏障。

对某个寄存器加个0&＃xff0c;这个操作跟没有是一样的&＃xff0c;没有任何作用&＃xff0c;简单称之为空指令&＃xff0c;

为什么有一个空指令存在&＃xff0c;因lock指令在锁总线的时候&＃xff0c;这条指令后面必须跟一条指令&＃xff0c;后面指令不能为空&＃xff0c;所以后面得跟一条指令&＃xff0c;但是后面跟的又不能有任何作用&＃xff0c;如果有任何作用&＃xff0c;中间改了别的值&＃xff0c;也不对&＃xff0c;所以设计了这么一个指令&＃xff0c;往某个寄存器上加了个0&＃xff0c;跟没有操作一样&＃xff0c;主要为了迎合lock指令的参数要求即后面必须跟一个指令&＃xff0c;其实只要有一个lock指令就足够了。

虽然lock后面加了个空操作&＃xff0c;但是lock起着锁总线的作用。

因特尔cpu设计的禁止重排序指令是mfense和lfense&＃xff0c;其实也没有想到hotspot会有lock这样的操作&＃xff0c;作为hotspot来讲&＃xff0c;不同的cpu应该做对应的优化&＃xff0c;不应该为了偷懒就直接使用了一条lock指令。

lock其实是很多底层的实现&＃xff0c;比如synchronized本身也是用lock来实现的&＃xff0c;volatile也是。

那lock到底是什么&＃xff1f;

lock并不能简单的认为是锁住总线&＃xff0c;想了解lock指令就相当于你要了解cpu级别的并发控制到底有哪些种&＃xff0c;cpu级别的对于多线程的内存并发控制&＃xff1a;

第一个叫关中断&＃xff1b;

第二种是缓存一致性协议&＃xff1b;

第三种是系统屏障&＃xff0c;系统屏障本身第一个级别是编译级别的屏障&＃xff0c;第二个级别是指令级别的屏障&＃xff1b;

第四种是总线和缓存锁lock cmpxchg memory或lock addl&＃xff0c;这条指令要么缓存锁&＃xff0c;要么总线锁&＃xff0c;所以它未必一定是总线锁&＃xff0c;想在cpu级别控制整个并发&＃xff0c;只有这四种 。

在操作系统在这四种最基本的操作之上会提供一系列的内核级别的api&＃xff0c;让你调用api去实现各种各样的锁。

各种各样的锁包括哪些东西&＃xff1f;

从linux内核的角度大概是包括这些内容&＃xff1a;信号量和P-V原语&＃xff08;也就是&＃43;-的操作&＃xff09;&＃xff0c;还有一个是互斥。

在这些个api的基础之上&＃xff0c;还有互斥量MUTEX、自旋锁CAS。

在自旋锁的基础上还会有读写锁、中断控制、内核抢占&＃xff0c;SEQ锁、序列锁、RCU锁。

在多cpu访问下必须要考虑访问同一个数据会出现数据不一致的问题&＃xff0c;cpu级别提供了4种控制的方式 &＃xff0c;在这4种控制方式的基础之上&＃xff0c;不同的操作系统提供了一系列内核级别的api&＃xff0c;在api的基础之上提供了一系列的锁来做并发控制。

在这些内核基础之上&＃xff0c;才完成了jvm级别的锁控制&＃xff0c;jvm级别除了原来的synchronized之外&＃xff0c;还有juc级别的锁&＃xff0c;比如cas级别的automic开头的原子类的操作。

在juc里面&＃xff0c;在所有底层的基础之上&＃xff0c;才会诞生了java这一系列的锁以及自己实现锁所需要的最原始的零件。

要了解jvm锁&＃xff0c;建议从底层开始了解&＃xff0c;所有上层的东西就是对最底层的一个封装而已。

jvm封装了pthread和kthread&＃xff0c;这种是linux内核级别的api&＃xff0c;它封装了cpu级别的4种方式&＃xff0c;提供的一系列的同步机制。