JVM知识体系学习四：排序规范（happens-before原则）、对象创建过程、对象的内存中存储布局、对象的大小、对象头内容、对象如何定位、对象如何分配

java冯坚持

已于 2023-04-12 17:23:37 修改

阅读量718

点赞数 1

分类专栏： JVM 文章标签： jvm 学习 java

于 2023-01-07 16:52:18 首次发布

本文链接：https://blog.csdn.net/qq_40036754/article/details/128555627

版权

JVM 专栏收录该内容

8 篇文章 4 订阅

订阅专栏

前言

外部资料：一文搞懂java对象创建过程
本博客主要讲了 happens-before原则；对象的几个重点问题：
1. 请解释一下对象的创建过程？
  - load、link(verification, preparation, resolution) 、initial、申请对象地址、成员变量赋默认值、构造方法（成员变量赋初始值）
2. 对象在内存中的存储布局？
  - 对象（对象头、类指针、实例数据、填充）和数组（对象头、类指针、数组长度、数组数据、填充）
3. 对象头具体包括什么？
  - 一张图；001、00、10、11、101
4. 对象怎么定位？
  - 句柄池或者直接指针
  - 外部资料：https://blog.csdn.net/clover_lily/article/details/80095580
5. 对象怎么分配？
  - GC相关内容
6. Object o = new Object在内存中占用多少字节？
  - 16字节

零、排序规范

java language Specification 中去找，去官网找到下图中去下载PDF。
这是java语言的一个要求，和JVM无关系。具体的由JVM去实现

1、happens-before原则

hanppens-before原则（JVM规定重排序必须遵守的规则）JLS17.4.5

程序次序规则：同一个线程内，按照代码出现的顺序，前面的代码先行于后面的代码，准确的说是控制流顺序，因为要考虑到分支和循环结构。
管程锁定规则：一个unlock操作先行发生于后面（时间上）对同一个锁的lock操作。
volatile变量规则：对一个volatile变量的写操作先行发生于后面（时间上）对这个变量的读操作。
线程启动规则：Thread的start( )方法先行发生于这个线程的每一个操作。
线程终止规则：线程的所有操作都先行于此线程的终止检测。可以通过Thread.join( ) 方法结束、Thread.isAlive( )的返回值等手段检测线程的终止。
线程中断规则：对线程interrupt( )方法的调用先行发生于被中断线程的代码检测到中断事件的发生，可以通过Thread.interrupt( )方法检测线程是否中断
对象终结规则：一个对象的初始化完成先行于发生它的finalize()方法的开始。
传递性：如果操作A先行于操作B，操作B先行于操作C，那么操作A先行于操作C
as if serial
不管如何重排序，单线程执行结果不会改变

2、找文档位置

链接在此：https://docs.oracle.com/javase/specs/index.html

下图就是文中所在的内容：Happens-before 原则。

一、一线互联网企业关于对象面试题：（后面回答的就是这几个问题）

请解释一下对象的创建过程？
对象在内存中的存储布局？
对象头具体包括什么？
对象怎么定位？
- 外部资料：https://blog.csdn.net/clover_lily/article/details/80095580
对象怎么分配？
- GC相关内容
Object o = new Object在内存中占用多少字节？

二、对象创建过程

对象的创建过程

class loading
class linking (verification, preparation, resolution)
class initializing
申请对象内存
成员变量赋默认值
调用构造方法<init>
1. 成员变量顺序赋初始值
2. 执行构造方法语句

三、对象在内存中的存储布局

1、1.8版本虚拟机配置

java -XX:PrintCommandLineFlags -version：
XX:PrintCommandLineFlags：打印命令行的参数。
在显示version（版本）时，打印出命令行所自带的参数配置。如下图所示：
虚拟机启动时，自带的参数就显现出来了：
1. -XX:InitialHeapSize=132582976
  初始化堆大小
2. -XX:MaxHeapSize=2121327616
  堆最大值
3. -XX:+PrintCommandLineFlags
  当前参数
4. -XX:+UseCompressedClassPointers
  与对象头有关系，对象头指向下面的class的指针，默认是8字节，加上这个命令行就变成了 4字节。
5. -XX:+UseCompressedOops
  与对象内存布局有关系
  下面这两个与GC有关系，后面讲
6. -XX:-UseLargePagesIndividualAllocation
7. -XX:+UseParallelGC

2、对象的内存布局

在Hotspot虚拟机里，对象在堆里的 内存布局 来讲，分为两种：
1. 普通对象
2. 数组对象
JVM 栈中的栈针中局部变量表的变量中，存储的是四种：基本数据类型（直接存放）、对象（如何定位呢，就是最下面要讲的句柄方式和直接指针方式）

a、普通对象

有些资料介绍对象包括对象头、实例数据、padding对齐，对象头包括markword和classpointer指针，其实和我下面介绍的没啥区别，只是把class pointer拿出来了。

对象头：markword 8个字节（在并发编程中很重要，下面第五章单独介绍）
ClassPointer指针：使用 -XX:+UseCompressedClassPointers 压缩后为4字节（默认开启），不开启为8字节，（一个对象，new出之后，这个对象属于哪个class，这里有个指针指向class的对象，）
实例数据（成员变量）：对象真正存储的有效信息，即我们在对象中定义的各种类型的字段内容，无论是父类继承过来的字段还是对象自身的字段都得记录下来。
- 引用类型：-XX:+UseCompressedOops 为4字节不开启为8字节
  Oops： Ordinary Object Pointers
Padding对齐，8的倍数。（比如算出来15个字节，但是64的机器，一块读64个字节，对齐为8的倍数。）
- 这并不是必然存在的，也没有特别的含义，它仅仅起着占位符的作用。

b、数组对象

对象头：markword 8
ClassPointer指针同上
数组长度：4字节（比普通对象多了这个）
数组数据
对齐 8的倍数

四、对象的大小

java 有一个agent的机制。

1、自定义 javaAgent查看对象大小

新建项目ObjectSize （1.8）

创建文件ObjectSizeAgent

package com.mashibing.jvm.agent;

import java.lang.instrument.Instrumentation;

public class ObjectSizeAgent {
    private static Instrumentation inst;

    public static void premain(String agentArgs, Instrumentation _inst) {
        inst = _inst;
    }

    public static long sizeOf(Object o) {
        return inst.getObjectSize(o);
    }
}

src目录下创建META-INF/MANIFEST.MF
```
Premain-Class: com.mashibing.jvm.agent.ObjectSizeAgent
```
注意Premain-Class这行必须是新的一行（回车 + 换行），确认idea不能有任何错误提示
打包jar文件（自行百度吧）
在需要使用该Agent Jar的项目中引入该Jar包，project structure - project settings - library 添加该jar包
运行时需要该Agent Jar的类，加入参数：-javaagent:C:\work\ijprojects\ObjectSize\out\artifacts\ObjectSize_jar\ObjectSize.jar（也就是在下面测试的程序中加上这个命令）

2、测试代码

package com.mashibing.jvm.c3_jmm;

import com.mashibing.jvm.agent.ObjectSizeAgent;

public class T03_SizeOfAnObject {
    public static void main(String[] args) {
        System.out.println(ObjectSizeAgent.sizeOf(new Object()));
        System.out.println(ObjectSizeAgent.sizeOf(new int[] {}));
        System.out.println(ObjectSizeAgent.sizeOf(new P()));
    }

    //一个Object占多少个字节
    // -XX:+UseCompressedClassPointers -XX:+UseCompressedOops
    // Oops = ordinary object pointers
    private static class P {
                        //8 _markword
                        //4 _class pointer
        int id;         //4
        String name;    //4
        int age;        //4

        byte b1;        //1
        byte b2;        //1

        Object o;       //4
        byte b3;        //1

    }
}

3、解析4.2的测试代码结果

默认带压缩测试：-XX:+UseCompressedClassPointers
1. new Object：为16个字节，对象头为8字节，ClassPointer 按说为8字节，但是使用了压缩命令 -XX:+UseCompressedClassPointers（默认的）所以为4字节，但是还有个padding对齐，为8的倍数，所以在加4个字节，就为8的倍数了，就是 8+4+4 = 16个字节。
2. new int[] {}：为16个字节，对象头8字节，ClassPointer 压缩后 4字节，数组长度为4字节，还未存数据，所以就是8+4+4=16个字节。
去掉压缩进行测试，ClassPointer 不压缩，在程序执行时加参数：-XX:-UseCompressedClassPointers ，就是将+号变成了-号即可。
1. 然后 new Object 还是 16（去掉了padding的4，ClassPointer 变成8）。
2. new int[]{} 变成了 24字节（对象头8+ClassPointer8+数组长度4 +还有padding对齐4=就是24了），
测试自己创建的对象，就是代码中的对象P（这里带压缩测试的）
1. MarkWord 对象头 8字节
2. ClassPointer指针 4字节
3. int id，为4字节
4. String name，按正常来说是8字节，但是这里是4字节，因为虚拟机默认的命令行有一个 -XX:+UseCompressedOops ，oops=ordinary object pointers，就是一般对象指针。连起来就是一般对象指针的压缩，这里就变成了 4字节（可以看出 class 对象普通对象是分开的）
  - -XX:-UseCompressedClassPointers：对象头指向 class的对象
  - -XX:+UseCompressedOops：成员变量的指针
5. byte 为 1字节
6. Object 为 4字节
7. 总结：加上对齐 32个字节。

五、对象头MarkWord具体包括什么

1、概述

（复杂）1.8实现，得看源码。
对象头 MarkWord的结构，定义在 markOop.hpp文件中：
在这里插入图片描述

第一行是32位系统的JVM的对象头
第八行是64位系统的JVM的对象头

2、MarkWord 的 64 位

下面这个图是用的32位的来讲的 64位的JVM对象头的储存 ，
（25+4+3 = 32位，这里使用32来描述64位，其实64位也就是上图中8-13行的描述。）

在这里插入图片描述

对象头8字节，也就是64位。
需要记住的是最右边的 是否偏向锁 和 锁标志位。一共三位来确定锁的状态
还有锁状态和锁标志位的对应。

在这里插入图片描述

问题1：什么时候会产生hashcode?
- 当然是调用未重写的hashcode()方法以及System.identityHashCode的时候
问题2：为什么GC年龄默认为15？（最大为15）
- 因为上面分代年龄就给了4位，最大就是15.

3、一些问题

在这里插入图片描述
问题：当一个对象计算过identityHashCode之后，不能进入偏向锁状态

红圈中这句话是对的，因为当一个对象已经计算过了 identity hash code。如下图所示：下面的线程ID 和Epoch 就无法写入了，所以就无法进入偏向锁了。

在这里插入图片描述

4、synchronized 参考资料

synchronized的加锁，使用方法三种：同步块，同步对象，同步方法。字节码层次，前两个是mointerenter和mointerexit来实现，同步方法是通过ACC_SYNCHRONIZED关键字来实现的。但 究其本质都是作用于对象 上。对象内存布局中对象头中的 markword 存放了很多重要的信息;当并发时，markword 根据锁的四种不同状态会进行不同的指向新的对象。

六、对象怎么定位？

当 T t = new T() new 出来的对象，如何找到实际中的对象呢
创建对象自然是为了后续方便使用对象，我们的java程序会通过 JVM栈 上的reference（引用）来操作堆上的具体对象。访问对象的方式有直接指针和使用句柄两种方式：
JVM 栈中的栈针中局部变量表的变量中，存储的是两种：8种基本数据类型（直接存放数值即可）、引用类型（即对象和数组；如何定位呢，就是这里要讲的句柄方式和直接指针方式）
由于reference（引用）类型（对象就是引用类型）在Java虚拟机规范里只规定了一个指向对象的引用，并没有定义这个引用应该通过哪种方式去定位，以及访问到Java堆中的对象的具体位置，因此不同虚拟机实现的对象访问方式会有所不同，主流的访问方式有两种：使用句柄和直接指针。
两种方式
1. 句柄池（间接指针）
2. 直接指针

1. 句柄池

通过一个间接指针（两个指针），一个是指向 对象实例数据 的指针，另一个是向 T.class 类型数据 的指针。
1. 对象实例数据（堆）:对象中各个实例字段的数据
2. 对象类型数据（方法区）：对象的类型、父类、实现的接口、方法等
3. 静态区（也在方法区中）用来存放静态变量、常量，静态块
如果使用句柄访问方式，Java堆中会划分出一块内存来作为句柄池，reference中存储的就是对象的句柄地址，而句柄中包含了对象实例数据（Java heap）和类型数据（method area）各自的具体地址信息。使用句柄方式最大的好处就是reference中存储的是稳定的句柄地址，在对象被移动（垃圾收集时移动对象是非常普遍的行为）时只会改变句柄中的实例数据指针，而reference本身不需要被修改。

2、直接指针

直接到对象类型数据中的指针，还有个指针直接指向 对象类型数据(类对象 T.class) 。
如果使用该方式，Java堆对象的布局就必须考虑 如何放置访问对象类型数据的相关信息，reference中直接存储的就是对象地址。使用直接指针方式最大的好处就是速度更快，他节省了一次指针定位的时间开销。

在这里插入图片描述

3、比较-总结

比较
1. 就 HotSpot 而言，他使用的是 直接指针访问方式 进行对象访问，但从整个软件开发的范围来看，各种语言和框架使用句柄来访问的情况也十分常见。
2. 第一种句柄方式效率低一些。
3. GC时第一种句柄方式效率比较高。
总结
1. 对象创建过程：检查new指令对应的类数据是否已初始化 -> 为对象分配内存 -> 对象初始化零值 -> 设置对象头 -> 调用构造函数初始化对象资源和状态
2. 对象内存布局：对象头（markword和classpointer），实例数据和对象填充。
3. 通过 压缩对象头的类型指针，引用类型和引用类型数组 来减少对象占用内存空间大小。
4. 对象访问方式：**直接指针(JVM使用)**和使用句柄。

七、对象如何分配

GC时在说。

补充

在这里插入图片描述

java冯坚持

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
JVM知识体系学习四：排序规范（happens-before原则）、对象创建过程、对象的内存中存储布局、对象的大小、对象头内容、对象如何定位、对象如何分配

JVM知识体系学习四：排序规范（happens-before原则）、对象创建过程、对象的内存中存储布局、对象的大小、对象头内容、对象如何定位、对象如何分配
复制链接

扫一扫