• java JUC并发编程 第九章 对象内存布局与对象头

    系列文章目录

    第一章 java JUC并发编程 Future: link
    第二章 java JUC并发编程 多线程锁: link
    第三章 java JUC并发编程 中断机制: link
    第四章 java JUC并发编程 java内存模型JMM: link
    第五章 java JUC并发编程 volatile与JMM: link
    第六章 java JUC并发编程 CAS: link
    第七章 java JUC并发编程 原子操作类增强: link
    第八章 java JUC并发编程 ThreadLocal: link
    第九章 java JUC并发编程 对象内存布局与对象头: link
    第十章 java JUC并发编程 Synchronized与锁升级: link
    第十一章 java JUC并发编程 AbstractQueuedSynchronizer之AQS: link

    文章目录

    1 概述

    1.1 对象的内存布局

    在这里插入图片描述
    在这里插入图片描述
    对象内部结构分为：对象头、实例数据、对齐填充（保证8个字节的倍数）
    对象头分为对象标记（markOop）和类元信息（klassOop）,类元信息存储的是指向改对象类元数据（klass）的首地址。

    1.1.1 对象头

    1.1.1.1 对象标记Mark Work

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    默认存储对象的HashCode、分代年龄和锁标志位等信息。这些信息都是与对象自身定义无关的数据，所以MarkWord被设计成一个非固定的数据结构以便在极小的空间内存存储尽量多的数据。它会根据对象的状态复用自己的存储空间，也就说在运行期间MarkWord里存储的数据会随着锁标志位的变化而变化

    1.1.1.2 类元信息/类型指针

    在这里插入图片描述
    类型指针是对象头的一部分，主要指向方法区的Customer的Klass类元信息，虚拟机通过这个指针来确定这个对象是哪个类的实例。

    1.1.1.3 对象头大小

    64位系统中，Mark Word 占了8个字节，类型指针占了8个字节，一共是16个字节。

    1.1.2 实例数据

    存放类的属性（Field）数据信心，包括父类的属性和信息

    1.1.3 对齐填充

    虚拟机要求对象起始地址必须是8字节的整数倍。填充数据不是必须存在的，仅仅是为了字节对齐这部分内存按8字节补充对齐。
    只有一个对象头的实例对象，16字节（忽略压缩指针的影响）,int 类型占4字节，boolean类型占1字节 -->对齐填充,24字节

    2 对象头MarkWord

    2.1 32位的了解一下

    在这里插入图片描述

    2.2 64位

    在这里插入图片描述
    在这里插入图片描述
    markword(64位)分布图，对象布局、GC回收和后面的锁升级就是对象标记MarkWord里面标志位的变化

    3 工具展现 Object obj = new Object()；

    3.1 JOL证明

    JOL官网：http://openjdk.java.net/projects/code-tools/jol/
    图形化以代码的形式展现一个对象在64位的虚拟机里面MarkWord、实例数据栈的大小、对齐填充
    在这里插入图片描述
    大意是：java对象的展现，是一个非常小巧的java对象的展现工具，可以给你提供分析对象的布局在java的虚拟机里面。
    要使用的话需要引入pom
    在这里插入图片描述

            <dependency>
            <groupId>org.openjdk.jol</groupId>
            <artifactId>jol-core</artifactId>
            <version>0.9</version>
        </dependency>

    • 1
    • 2
    • 3
    • 4
    • 5

    3.2 代码

    package com.atguigu.springcloud.util.interrup;

import org.openjdk.jol.info.ClassLayout;
import org.openjdk.jol.vm.VM;

public class JOLDemo {
    public static void main(String[] args) {
        //Thread.currentThread
//        System.out.println(VM.current().details());
        /**
         * 上面输出到控制台的内容
         *
         * # Running 64-bit HotSpot VM.                             //64位HotSpot的虚拟机
         * # Using compressed oop with 3-bit shift.                 //压缩的oop
         * # Using compressed klass with 3-bit shift.               //压缩的类型
         * # Objects are 8 bytes aligned.                           //按照8字节对齐
         * # Field sizes by type: 4, 1, 1, 2, 2, 4, 4, 8, 8 [bytes] //文件大小
         * # Array element sizes: 4, 1, 1, 2, 2, 4, 4, 8, 8 [bytes] //元素大小
         */

        //对象的对齐数
//        System.out.println(VM.current().objectAlignment());
        /**
         * 上面输出到控制台的内容
         * 8
         */

        Object o = new Object();
        //                              转换这个实例
//        System.out.println(ClassLayout.parseInstance(o).toPrintable());
        /**
         * 上面ClassLayout.parseInstance(o).toPrintable()输出到控制台的内容：
         *
         * java.lang.Object object internals: //内部信息的描述
         *  OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
         *       0(开始)4（结束）  (object header)                           01 00 00 00 (00000001 00000000 00000000 00000000) (1)
         *       4(上4) 4      (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
         *       8     4        (object header)                           e5 01 00 f8 (11100101 00000001 00000000 11111000) (-134217243)
         *      12     4        (loss due to the next object alignment（丢失以后为下个对象进行补齐）)
         * Instance size: 16 bytes  //结论：new 一个Object的默认大小就是16bytes
         * Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
         */

        //运行的时候先注释掉Customer中的两个属性
//        Customer c1 = new Customer();
//        System.out.println(ClassLayout.parseInstance(c1).toPrintable());
        /**
         * 上面的ClassLayout.parseInstance(c1).toPrintable()输出结果： 默认也是16字节和上面的object对象一样
         * //对象头Customer的内部结构
         * com.atguigu.springcloud.util.interrup.Customer object internals:
         *  OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
         *       0     4        (object header)                           01 00 00 00 (00000001 00000000 00000000 00000000) (1)
         *       4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
         *       8     4        (object header)                           43 c1 00 f8 (01000011 11000001 00000000 11111000) (-134168253)
         *      12     4        (loss due to the next object alignment)
         * Instance size: 16 bytes
         * Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
         */

        /**
         * 上面有个问题为什么类型指针是4字节？
         */

        //运行的时候注意需要有int 和 bolean 两个属性
        Customer c2 = new Customer();
        System.out.println(ClassLayout.parseInstance(c2).toPrintable());

        /**
         * 上面输出ClassLayout.parseInstance(c2).toPrintable()运行结果：
         *
         * com.atguigu.springcloud.util.interrup.Customer object internals:
         *  OFFSET  SIZE      TYPE DESCRIPTION                               VALUE
         *       0     4           (object header)                           01 00 00 00 (00000001 00000000 00000000 00000000) (1)
         *       4     4           (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
         *       8     4           (object header)                           43 c1 00 f8 (01000011 11000001 00000000 11111000) (-134168253)
         * //4位                   Customer对象描述                          初始值
         *      12     4       int Customer.id                               0
         * //boolean是 1位                                                  初始值
         *      16     1   boolean Customer.flag                             false
         *           补7位到8的倍数24
         *      17     7           (loss due to the next object alignment)
         * Instance size: 24 bytes
         * Space losses: 0 bytes internal + 7 bytes external = 7 bytes total
         */
    }
}
//只有一个对象头的实例对象，16字节（忽略压缩指针的影响）+4字节+1字节=21字节---->对齐填充,24字节
class Customer{
    //1.第一种情况，只有对象头，没有其他任务数据实例

    //2.第二种情况,int + boolean，满足对齐填充24字节
    int id;
    boolean flag =false;

}
//JOL=java object layOut

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96

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

    3.3 GC年龄采用4位bit存储，最大为15,

    例如MaxTenuringThreshold参数默认值就是15
    为什么是15 因为64位虚拟机表示分代年龄的大小是4bit.所以最大就是2进制的四个1（1111）就是15

    在这里插入图片描述

    3.3.1 实例证明

    1.编辑JVM虚拟机的分代年龄参数：-XX:MaxTenuringThreshold=16
    如果不指定上面的的参数默认就是15，必须要小于15，为了演示写成16
    在这里插入图片描述
    2.运行上面的代码
    结果连虚拟机都不能创建
    在这里插入图片描述

    3.4 压缩指针相关命令说明

    打印出启动时的全部参数
    java -XX:+PrintCommandLineFlags -version
    默认开启压缩说明：
    1.初始化堆内存 2.最大堆内存 4.压缩过类型指针（可以解释前面的为什么类型指针为4的问题）
    在这里插入图片描述
    手动关闭压缩再看看
    -XX:-UseCompressedClassPointers
    在这里插入图片描述
    在这里插入图片描述
    没有对齐填充直接到16字节
    不管是否压缩指针，只有一个对象头的话都是16字节
    在这里插入图片描述

  • 相关阅读:
    个人设计web前端大作业 HTML期末大作业 学生个人网页设计作品 学生个人网页设计作品 学生个人网页模板 简单个人主页成品
    React-Hooks源码深度解读
    springmvc、springBoot---第二篇
    python中time模块简单总结
    AutoDL使用手册
    Chapter6视觉处理基础
    orchestrator数据库高可用组件搭建
    Oracle实现主键字段自增
    RIP解决不连续子网问题
    系统分析与设计 复习
  • 原文地址：https://blog.csdn.net/zk13120778155/article/details/133069712