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

简介: 这篇文章详细地介绍了Java对象的创建过程、内存布局、对象头的MarkWord、对象的定位方式以及对象的分配策略,并深入探讨了happens-before原则以确保多线程环境下的正确同步。

前言

  • 外部资料:一文搞懂java对象创建过程
  • 本博客主要讲了 happens-before原则;对象的几个重点问题:
    1. 请解释一下对象的创建过程?
      • load、link(verification, preparation, resolution) 、initial、申请对象地址、成员变量赋默认值、构造方法(成员变量赋初始值)
    2. 对象在内存中的存储布局?
      • 对象(对象头、类指针、实例数据、填充) 和 数组(对象头、类指针、数组长度、数组数据、填充)
    3. 对象头具体包括什么?
      • 一张图;001、00、10、11、101
    4. 对象怎么定位?
    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、找文档位置

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

  1. 请解释一下对象的创建过程?
  2. 对象在内存中的存储布局?
  3. 对象头具体包括什么?
  4. 对象怎么定位?
  5. 对象怎么分配?
    • GC相关内容
  6. Object o = new Object在内存中占用多少字节?

二、对象创建过程

对象的创建过程

  1. class loading
  2. class linking (verification, preparation, resolution)
  3. class initializing
  4. 申请对象内存
  5. 成员变量赋默认值
  6. 调用构造方法<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拿出来了。

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

b、数组对象

  1. 对象头:markword 8
  2. ClassPointer指针同上
  3. 数组长度:4字节(比普通对象多了这个)
  4. 数组数据
  5. 对齐 8的倍数

四、对象的大小

java 有一个agent的机制。

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

  1. 新建项目ObjectSize (1.8)
  2. 创建文件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);
        }
    }
    
  3. src目录下创建META-INF/MANIFEST.MF

    Premain-Class: com.mashibing.jvm.agent.ObjectSizeAgent
    

    注意Premain-Class这行必须是新的一行(回车 + 换行),确认idea不能有任何错误提示

  4. 打包jar文件(自行百度吧)
  5. 在需要使用该Agent Jar的项目中引入该Jar包,project structure - project settings - library 添加该jar包
  6. 运行时需要该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文件中:
在这里插入图片描述

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

2、MarkWord 的 64 位

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

在这里插入图片描述

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

在这里插入图片描述

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

3、一些问题

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

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

在这里插入图片描述
在这里插入图片描述

4、synchronized 参考资料

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

  1. 死磕Synchronized底层实现,面试你还怕什么?:https://cloud.tencent.com/developer/article/1480590
  2. 面试题深入解析:Synchronized底层实现:https://cloud.tencent.com/developer/article/1484167
  3. 死磕Synchronized底层实现–重量级锁:https://cloud.tencent.com/developer/article/1485795
  4. 一文让你读懂Synchronized底层实现-轻量级锁:https://cloud.tencent.com/developer/article/1482500

六、对象怎么定位?

  • 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时在说。

补充

在这里插入图片描述

相关文章
|
20天前
|
Arthas 监控 Java
JVM进阶调优系列(9)大厂面试官:内存溢出几种?能否现场演示一下?| 面试就那点事
本文介绍了JVM内存溢出(OOM)的四种类型:堆内存、栈内存、元数据区和直接内存溢出。每种类型通过示例代码演示了如何触发OOM,并分析了其原因。文章还提供了如何使用JVM命令工具(如jmap、jhat、GCeasy、Arthas等)分析和定位内存溢出问题的方法。最后,强调了合理设置JVM参数和及时回收内存的重要性。
|
21天前
|
存储 编译器 Linux
【c++】类和对象(上)(类的定义格式、访问限定符、类域、类的实例化、对象的内存大小、this指针)
本文介绍了C++中的类和对象,包括类的概念、定义格式、访问限定符、类域、对象的创建及内存大小、以及this指针。通过示例代码详细解释了类的定义、成员函数和成员变量的作用,以及如何使用访问限定符控制成员的访问权限。此外,还讨论了对象的内存分配规则和this指针的使用场景,帮助读者深入理解面向对象编程的核心概念。
47 4
|
2月前
|
缓存 算法 Java
JVM知识体系学习六:JVM垃圾是什么、GC常用垃圾清除算法、堆内存逻辑分区、栈上分配、对象何时进入老年代、有关老年代新生代的两个问题、常见的垃圾回收器、CMS
这篇文章详细介绍了Java虚拟机(JVM)中的垃圾回收机制,包括垃圾的定义、垃圾回收算法、堆内存的逻辑分区、对象的内存分配和回收过程,以及不同垃圾回收器的工作原理和参数设置。
72 4
JVM知识体系学习六:JVM垃圾是什么、GC常用垃圾清除算法、堆内存逻辑分区、栈上分配、对象何时进入老年代、有关老年代新生代的两个问题、常见的垃圾回收器、CMS
|
2月前
|
存储 算法 Java
Java虚拟机(JVM)的内存管理与性能优化
本文深入探讨了Java虚拟机(JVM)的内存管理机制,包括堆、栈、方法区等关键区域的功能与作用。通过分析垃圾回收算法和调优策略,旨在帮助开发者理解如何有效提升Java应用的性能。文章采用通俗易懂的语言,结合具体实例,使读者能够轻松掌握复杂的内存管理概念,并应用于实际开发中。
|
2月前
|
Java 应用服务中间件 程序员
JVM知识体系学习八:OOM的案例(承接上篇博文,可以作为面试中的案例)
这篇文章通过多个案例深入探讨了Java虚拟机(JVM)中的内存溢出问题,涵盖了堆内存、方法区、直接内存和栈内存溢出的原因、诊断方法和解决方案,并讨论了不同JDK版本垃圾回收器的变化。
32 4
|
2月前
|
存储 监控 算法
JVM调优深度剖析:内存模型、垃圾收集、工具与实战
【10月更文挑战第9天】在Java开发领域,Java虚拟机(JVM)的性能调优是构建高性能、高并发系统不可或缺的一部分。作为一名资深架构师,深入理解JVM的内存模型、垃圾收集机制、调优工具及其实现原理,对于提升系统的整体性能和稳定性至关重要。本文将深入探讨这些内容,并提供针对单机几十万并发系统的JVM调优策略和Java代码示例。
55 2
|
2月前
|
Arthas 监控 Java
JVM知识体系学习七:了解JVM常用命令行参数、GC日志详解、调优三大方面(JVM规划和预调优、优化JVM环境、JVM运行出现的各种问题)、Arthas
这篇文章全面介绍了JVM的命令行参数、GC日志分析以及性能调优的各个方面,包括监控工具使用和实际案例分析。
53 3
|
2月前
|
Java 测试技术 Android开发
让星星⭐月亮告诉你,强软弱虚引用类型对象在内存足够和内存不足的情况下,面对System.gc()时,被回收情况如何?
本文介绍了Java中四种引用类型(强引用、软引用、弱引用、虚引用)的特点及行为,并通过示例代码展示了在内存充足和不足情况下这些引用类型的不同表现。文中提供了详细的测试方法和步骤,帮助理解不同引用类型在垃圾回收机制中的作用。测试环境为Eclipse + JDK1.8,需配置JVM运行参数以限制内存使用。
34 2
|
2月前
|
存储 Kubernetes 架构师
阿里面试:JVM 锁内存 是怎么变化的? JVM 锁的膨胀过程 ?
尼恩,一位经验丰富的40岁老架构师,通过其读者交流群分享了一系列关于JVM锁的深度解析,包括偏向锁、轻量级锁、自旋锁和重量级锁的概念、内存结构变化及锁膨胀流程。这些内容不仅帮助群内的小伙伴们顺利通过了多家一线互联网企业的面试,还整理成了《尼恩Java面试宝典》等技术资料,助力更多开发者提升技术水平,实现职业逆袭。尼恩强调,掌握这些核心知识点不仅能提高面试成功率,还能在实际工作中更好地应对高并发场景下的性能优化问题。
|
4月前
|
存储 编译器 C语言
【C语言篇】数据在内存中的存储(超详细)
浮点数就采⽤下⾯的规则表⽰,即指数E的真实值加上127(或1023),再将有效数字M去掉整数部分的1。
395 0