第八章-对象的实例化内存布局与访问定位

时间:2021-09-06 06:11:05   收藏:0   阅读:11

1.对象的实例化

技术分享图片

1.1 大厂面试题

美团

  1. 对象在JVM中是怎么存储的?

  2. 对象头信息里面有哪些东西?

蚂蚁金服

二面:java对象头里有什么?

1.2 创建对象的方式

1.3 创建对象的步骤

技术分享图片

从字节码角度看待对象的创建过程

public class ObjectTest {
    public static void main(String[] args) {
        Object obj = new Object();
    }
}
0: new           #2                  // class java/lang/Object
3: dup
4: invokespecial #1                  // Method java/lang/Object."<init>":()V
7: astore_1
8: return

1.3.1 判断对象对应的类是否加载、链接、初始化

1.3.2 为对象分配内存

这个步骤有两个问题:

1.如何划分内存。

2.在并发情况下, 可能出现正在给对象A分配内存,指针还没来得及修改,对象B又同时使用了原来的指针来分配内存的情况。

划分内存的方法:(默认用指针碰撞)

处理并发安全问题

1.3.3 初始化零值

1.3.4 设置对象的对象头

1.3.5 执行init方法进行初始化

因此一般来说(由字节码中跟随invokespecial指令所决定),new指令之后会接着就是执行init方法,把对象按照程序员的意愿进行初始化,这样一个真正可用的对象才算完成创建出来。

从字节码角度看待init方法

/**
 * 测试对象实例化的过程
 *  ① 加载类元信息 - ② 为对象分配内存 - ③ 处理并发问题  - ④ 属性的默认初始化(零值初始化)
 *  - ⑤ 设置对象头的信息 - ⑥ (属性的显式初始化/代码块中初始化 两者按照排序顺序执行,谁在前谁先执行)构造器中初始化
 *
 *  给对象的属性赋值的操作:
 *  ① 属性的默认初始化 - ② 显式初始化 / ③ 代码块中初始化 - ④ 构造器中初始化
 */
public class Customer{
    int id = 1001;
    String name;
    Account acct;

    {
        name = "匿名客户";
    }
    
    public Customer(){
        acct = new Account();
    }

}
class Account{

}

2.对象的内存布局

技术分享图片

2.1 对象头

对象头包含两部分:运行时元数据(Mark Word)和类型指针

说明:如果对象是数组,还需要记录数组的长度

32位对象头

技术分享图片

2.2 实例数据

2.3 对齐填充

不是必须的,也没特别含义,仅仅起到占位符的作用

2.4对象大小与指针压缩

对象大小可以用jol-core包查看,引入依赖

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

import org.openjdk.jol.info.ClassLayout;

/**
 * 计算对象大小
 */
public class JOLSample {

    public static void main(String[] args) {
        ClassLayout layout = ClassLayout.parseInstance(new Object());
        System.out.println(layout.toPrintable());

        System.out.println();
        ClassLayout layout1 = ClassLayout.parseInstance(new int[]{});
        System.out.println(layout1.toPrintable());

        System.out.println();
        ClassLayout layout2 = ClassLayout.parseInstance(new A());
        System.out.println(layout2.toPrintable());
    }

    // -XX:+UseCompressedOops           默认开启的压缩所有指针
    // -XX:+UseCompressedClassPointers  默认开启的压缩对象头里的类型指针Klass Pointer,不压缩成员变量,只压缩类型指针
    // Oops : Ordinary Object Pointers
    public static class A {
                       //8B mark word
                       //4B Klass Pointer   如果关闭压缩-XX:-UseCompressedClassPointers或-XX:-UseCompressedOops,则占用8B
        int id;        //4B
        String name;   //4B  如果关闭压缩-XX:-UseCompressedOops,则占用8B
        byte b;        //1B 
        Object o;      //4B  如果关闭压缩-XX:-UseCompressedOops,则占用8B
    }
}



运行结果

java.lang.Object object internals:
OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
     0     4        (object header)                           01 00 00 00 (00000001 00000000 00000000 00000000) (1)    //mark word
     4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)    //mark word     
     8     4        (object header)                           e5 01 00 f8 (11100101 00000001 00000000 11111000) (-134217243)    //Klass Pointer
    12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

[I 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)                           6d 01 00 f8 (01101101 00000001 00000000 11111000) (-134217363) //如果对象是数组,还需要记录数组的长度
    12     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
    16     0    int [I.<elements>                             N/A
Instance size: 16 bytes
Space losses: 0 bytes internal + 0 bytes external = 0 bytes total


com.tuling.jvm.JOLSample$A 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)                           61 cc 00 f8 (01100001 11001100 00000000 11111000) (-134165407)
    12     4                int A.id                                      0
    16     1               byte A.b                                       0
    17     3                    (alignment/padding gap) // 和上面的byte A.b 的1字节构成4字节 进行对齐           
    20     4   java.lang.String A.name                                    null
    24     4   java.lang.Object A.o                                       null
    28     4                    (loss due to the next object alignment)
Instance size: 32 bytes
Space losses: 3 bytes internal + 4 bytes external = 7 bytes total

什么是java对象的指针压缩?

1.jdk1.6 update14开始,在64bit操作系统中,JVM支持指针压缩

2.jvm配置参数:UseCompressedOops,compressed--压缩、oop(ordinary object pointer)--对象指针

3.启用指针压缩:-XX:+UseCompressedOops(默认开启),禁止指针压缩:-XX:-UseCompressedOops

为什么要进行指针压缩?

1.在64位平台的HotSpot中使用32位指针(实际存储用64位),内存使用会多出1.5倍左右,使用较大指针在主内存和缓存之间移动数据,占用较大宽带,同时GC也会承受较大压力

2.为了减少64位平台下内存的消耗,启用指针压缩功能

3.在jvm中,32位地址最大支持4G内存(2的32次方),可以通过对对象指针的存入堆内存时压缩编码、取出到cpu寄存器后解码方式进行优化(对象指针在堆中是32位,在寄存器中是35位,2的35次方=32G),使得jvm只用32位地址就可以支持更大的内存配置(小于等于32G)

4.堆内存小于4G时,不需要启用指针压缩,jvm会直接去除高32位地址,即使用低虚拟地址空间

5.堆内存大于32G时,压缩指针会失效,会强制使用64位(即8字节)来对java对象寻址,这就会出现1的问题,所以堆内存不要大于32G为好,否则会占用大量的带宽,并且gc的压力也会变强

关于对齐填充:对于大部分处理器,对象以8字节整数倍来对齐填充都是最高效的存取方式。

2.4 内存布局总结

技术分享图片

3.对象的访问定位

JVM是如何通过栈帧中的对象引用访问到其内部的对象实例呢?

技术分享图片

技术分享图片

3.1 句柄访问

技术分享图片

3.2 直接指针(HotSpot采用)

技术分享图片

原文:https://www.cnblogs.com/tangliMeiMei/p/15228856.html

评论(0)
© 2014 bubuko.com 版权所有 - 联系我们:wmxa8@hotmail.com
打开技术之扣,分享程序人生!