文章目录提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档
- 一、并发编程之有序性
- 1.乱序验证
- 2.为何会存在乱序
- 3.重排序规则
- 4.如何阻止乱序
- 3.美团追魂七连问
- 总结
一、并发编程之有序性 1.乱序验证
代码如下(示例):
public class day04 {
private static int x = 0,y = 0;
private static int a = 0,b = 0;
public static void main(String[] args) throws InterruptedException {
for (long i = 0; i < Long.MAX_VALUE; i++) {
x = 0;
y = 0;
a = 0;
b = 0;
CountDownLatch latch = new CountDownLatch(2);
Thread one = new Thread(()->{
a = 1;
x = b;
latch.countDown();
});
Thread other = new Thread(()->{
b = 1;
y = a;
latch.countDown();
});
one.start();
other.start();
latch.await();
String result = "第"+i+"次("+x+","+y+")";
if (x==0&&y==0){
System.out.println(result);
break;
}
}
}
}
执行结果:
根据代码的内容,对不发生执行顺序改变的情况进行了排列组合,为左侧6个结果。想要得到x=0,y=0则为右边下面的执行顺序。说明代码执行的顺序确实发生了改变。
从底层来讲,cpu为了提高效率进行的一个优化机制,代码的执行顺序,有可能会被编译器、CPU 根据某种策略调整顺序。一个 CPU 指令的执行过程可以分成 4 个阶段:取指、译码、执行、写回。这 4 个阶段分别由 4 个独立物理执行单元来完成。这种情况下,如果指令之间没有依赖关系,后一条指令并不需要等到前一条指令完全执行完成再开始执行。而是前一条指令完成取指之后,后一条指令便可以开始执行取指操作。
而乱序并不影响单线程的最终一致性。
- 对象半初始化状态
代码如下:
public class day04 {
public static void main(String[] args) throws InterruptedException {
Object o = new Object();
}
}
在IDE中安装jclasslib插件,编译程序后,点击View标签,选择Show ByteCode With Jclasslib。得到如下结果:
第一句为:申请内存
第二句:暂略
第三句:特殊调用:其构造方法
第四句:和小o建立引用关联。
第五句:略。
也即是说,在上图中,invokespecial #3
- this对象逸出:
由于第三条和第四条执行时有可能互换顺序,已经建立引用连接但是对象还没有初始化完成,所以有可能发生打印出0的情况。我们可以称之为this对象逸出。所以不要在构造方法中将线程启动。可以另写一个方法启动线程。
示例:以下程序有一定几率可能输出为0;
public class day04 {
private int num = 8;
public day04(){
new Thread(()->{
System.out.println(this.num);
}).start();
}
public static void main(String[] args) throws InterruptedException, IOException {
new day04();
System.in.read();
}
}
3.重排序规则
JVM级别(不是CPU级别)的重排序原则:不需要记住了解即可。
CPU汇编指令级:添加内存屏障(barrier),也就是一条特殊的指令。例如:指令:A、B之间加一条内存屏障指令。比如intel的指令:Ifence sfence mfence(CPU特有指令)。即可阻止乱序。
JVM中的内存屏障:
他要求所有JVM的实现,必须有实现这四种内存屏障的机制,没有实际的JVM级别的汇编指令,只要有机制能实现即可。
用volatile实现禁止指令重排:
volatile修饰的变量,在写时会在前后都加上StoreStoreBarrier屏障,在读时会在后面加上LoadLoadBarrier、LoadStoreBarrier屏障。以此来禁止指令的重排序。
volatile在hotspot中的实现:
其中的lock本身也是一条内存屏障指令。lock后面必须要加一个指令操作,相当于是对后面这条指令的锁定,addl的操作给寄存器加了一个0,取了个巧相当于是个空操作。
- 请解释一下对象的创建过程(半初始化)
- 请问DCL与volatile问题?(指令重排)
DCL:Double Check Lock,比如:单例模式。
volatile:1.保持线程可见性。2.禁止指令重排序,它会对修饰的内存前后加屏障。
结论:要加volatile。
对象半初始化状态中说过,图上的指令可能发生重排,则先建立引用关联。此时还没有初始化完得时候,如果有线程走到第一个INSTANCE==null 的判断,则会认为条件不成立,直接返回的INSTANCE处于半初始化状态。
volatile禁止指令重排序的规则:
1.当第二个操作是voaltile写时,无论第一个操作是什么,都不能进行重排序
2.当第一个操作是volatile读时,不管第二个操作是什么,都不能进行重排序
3.当第一个操作是volatile写时,第二个操作是volatile读时,不能进行重排序
- 对象在内存中的存储布局?(对象与数组的存储不同)。
markword:标记字。
class pointer:对象属于哪个Class。例:属于T就指向T.class。
instance data:比如之前的m变量就属于这里。
padding:64位虚拟机即8字节对齐,前面所有加起来不能被8整除就补齐到可以。
额外小知识:
命令框执行:“java -XX:+PrintCommandLineFlags - version”
-X:+UseCompressedClassPointers (Compressed->压缩) 默认启动压缩。 压缩后为4字节不压缩为8字节。内存超过32G,压缩即失效。
-X:+UseCompressedOops (Oop -->Ordinary object pointer ) 默认启动压缩。 压缩后为4字节不压缩为8字节。内存超过32G,压缩即失效。
普通对象指针,比如对象中有一个字符串变量s指向一个String对象,s即为普通对象指针。也是默认启动压缩。
数组和对象区别不大,多了一个四字节的数组长度。所以数组最大长度为一个int类型的最大值。
- 对象头具体包括什么?(markword klasspointer)synchronized锁信息
加入上图依赖,然后运行以下程序:
public class Day04 {
private static class T {
int m = 8;
int x = 8;
}
public static void main(String[] args) {
T o = new T();
String s = ClassLayout.parseInstance(o).toPrintable();
System.out.println(s);
}
}
运行结果如下:
由此可见对象头主要包括markword和class pointer,前两行记录了从0到8字节是markword,第三行4个字节为压缩后的class pointer,第四行记录了一个int类型的变量,第五行记录了对象中的变量的指针即(Ordinary object pointer)。最后一行则是padding(对齐)部分。不能被8字节整除时补齐。对象总大小为24个字节。markword中包括锁信息、hashcode、GC信息。最主要关心的是锁信息。
来看下面这两段段代码的运行结果:
public class Day04 {
private static class T {
int m = 8;
}
public static void main(String[] args) {
T o = new T();
String s = ClassLayout.parseInstance(o).toPrintable();
System.out.println(s);
synchronized (o){
System.out.println(ClassLayout.parseInstance(o).toPrintable());
}
}
}
是否加锁,输出的结果完全不一样。详情会在之后部分讲到。今天只做了解。
public class Day04 {
private static class T {
int m = 8;
}
public static void main(String[] args) {
T o = new T();
String s = ClassLayout.parseInstance(o).toPrintable();
System.out.println(s);
o.hashCode();
System.out.println(ClassLayout.parseInstance(o).toPrintable());
}
}
这里的hashcode是Identity Hashcode。详情容后。
-
对象怎么定位?(直接 间接)
第一种是通过句柄池,第二种是通过直接指针。所谓定位就是怎么通过,t找到new出来的T类型对象。hotspot采用直接指针指向对象,对象中存储的的类型数据指针指向其class,也就是第二种。第一种,是通过指针指向一个结构体,结构体包含一个数据实例指针一个数据类型指针,实例指针指向对象,数据类型指针指向对象的class。 -
对象怎么分配?(栈上-线程本地-Eden-Old)
首先在尝试栈上分配,处于栈上的好处是,效率极高,一旦弹出整个对象的生命周期就结束了(需要满足逃逸分析可以进行标量替换就可以在栈上分配);不能在栈上分配看是否大,如果大就放在老年带(Old)上分配,老年带上经过FGC才能回收对象;如果不大不小不能在栈上分配,就往TLAB(Thread Local Aclocation Buffer线程本地分配缓冲区)上分配;在TLAB分配不下,会去(新生带)Eden区分配。当我们往一块内存区域new对象,总是要分配空间的,当有很多线程都在抢这块空间时,必须要经过同步,否则可能刚写完就被覆盖了,所以需要做线程协调,就会损失效率,所以Hotspot中设计了TLAB,当一个线程启动的时候,在Eden区中为线程分配一块小小的空间由该线程独享,线程中new的对象往里扔,就不需要抢,不用线程协调,效率较高。Eden区中经过GC回收如果回收就结束,如果没有回收掉就会到Server1,Server1再经过回收,年龄到了就到老年带,年龄不够进入Server2,Server2再经过回收,如此循环往复。
-
Object o = new Object()在内存中占用多少字节?
首先看是否启用了Oops压缩及class pointer的压缩,没压缩两个指针均为8字节,压缩以后是4字节,还有内存是32G以下还是以上。32G以下,且都启用了压缩,则总共占了20个字节。markword占8字节,class pointer 占4字节,padding占4字节,最后一个o占4字节,所以总共占了20个字节。 -
为什么hotspot不使用C++对象来表示java对象?
C++对象中有一个Vtbl指针,它指向虚方发表(虚方法表用来实现多态),在java里使用了Oop-klass二元机制。当newT()对象时,会new对应OopDesc对象(C++对象),会生成一个T.class对应的C++对象(称之为INSTANCEKLASS),如果T的klass(C++对象)没有,生成一个INSTANTCEKLASS这样一个对象,所以称为Oop-klass这样一个组合。如果有就不用再生成。这样生成对象小一些,不用每次记录虚方法表,虚方法表放在Klass对象中 。 -
Class对象是在堆还是在方法区?
方法区(method area),
o在栈中,而Object对象在堆中,他有一个指针指向了方法区中的instanceClassOop对象(c++对象),这个instanceClassOop对象又有一个指针指向了O.class。经过了一个转折,所以可以说Class实例在方法区中。这个Class实例是给反射用的。
总结
CPU是可以乱序执行的,主要是为了提高效率。底层原则,不影响单线程的最终一致性。多线程时可能会产生this的逸出或半初始化状态,在JVM级别也规定了一些指令不能换顺序。四种内存屏障的讲解。可以通过volatile阻止乱序的发生。以及9道面试题解。



