java对象的内存布局


写java时不管是我们自己new对象还是spring管理bean,尽管我们天天跟对象打交道,那么对象的结构和内存布局有多少人知道呢,这篇文章可带你入门,了解java对象内存布局。
本文涉及到JVM指针压缩的知识点,不熟悉的小伙伴可以看前面写过的一篇关于指针压缩的文章。
JVM之指针压缩

首先说明,本文涉及的JDK版本是1.8,JVM虚拟机是64位的HotSpot实现为准。

java对象结构

关于java对象我们知道, 对象的实例是存在堆上的, 对象的元数据存在方法区(元空间)上,对象的引用保存在栈上的。那么java对象的结构是什么样的呢,其实java对象由三部分构成。

  1. 对象头

对象头里也有三部分构成。

  • Markword

存储对象的hashCode、垃圾回收对象的年龄以及锁信息等。

  • 类型指针

对象指向的类信息地址即元数据指针,比如User对象指针指向User.class的JVM内存地址。注意:jdk1.8以后元数据是存在Metaspace里的,jdk1.8之前是在方法区里

  • 数组长度

只有对象是数组的情况下,才有这部分数据,若对象不是数组,则没有这部分,不分配空间。

  1. 对象体

对象里的非静态属性占用的空间(包括父类的所有属性,不区分修饰类型),不包括方法,注意:是非静态属性,属于对象的属性,静态属性是属于类的不在对象上分配空间。如果属性是基本数据类型,则直接存对象本身,如果是引用类型,则存的是对象的指针。

  1. 对齐填充

默认情况下,如果对象头+对象体大小不是8字节的倍数,则通过该部分进行补齐,比如对象头+对象体大小只有30字节,则需要补齐到32字节,这里的对齐填充就是2字节。默认情况下,JVM中对象是以8字节对齐的,若对象头加上对象体是8的倍数时,则不存在字节对齐,否则会填充补齐到8的倍数。
对象结构如下图所示。


通过图中可以看出,数组对象只是在对象头里多了数组长度这一项,普通对象(非数组对象)没有这项,也不分配内存空间。
对象结构及占用空间大小如下图所示。

涉及指针压缩的地方有两个,一个是对象头里的类型指针,一个是对象体里的引用类型指针,这篇文章里有详细的介绍:JVM之指针压缩

对象头

对象头包含三部分

  • Markword:存储对象自身运行时数据如hashcode、gc分代年龄及锁信息等,64位系统总共占用8个字节。
  • 类型指针:对象指向类元数据地址的指针,jdk8默认开启指针压缩,64位系统占4个字节
  • 数组长度:若对象不是数组,则没有该部分,不分配空间大小,若是数组,则为4个字节长度

对象头占用空间大小如下表所示。

Markword

存储对象自身运行时数据如hashcode、gc分代年龄及锁信息等,64位系统总共占用8个字节,也就是64bit,64位的二进制0和1。


解释如下:

  • 对象的hashCode占31位,重写类的hashCode方法返回int类型,只有在无锁情况下,是在有调用的情况下会计算该值并写到对象头中,其他情况该值是空的。
  • 分代年龄占4位,最大值也就是15,在GC中,当survivor区中对象复制一次,年龄加1,默认是到15之后会移动到老年代。
  • 是否偏向锁占1位,无锁和偏向锁的最后两位都是01,使用这一位来标识区分是无锁还是偏向锁。
  • 锁标志位占2位,锁状态标记位,同是否偏向锁标志位标识对象处于什么锁状态。
  • 偏向线程ID占54位,只有偏向锁状态才有,这个ID是操作系统层面的线程唯一id,跟java中的线程id是不一致的。

类型指针

类型指针指向类的元数据地址,JVM通过这个指针确定对象是哪个类的实例。32位的JVM占32位,4个字节,64位的JVM占64位,8个字节,但是64位的JVM默认会开启指针压缩,压缩后也只占4字节。
64位虚拟机中在堆内存小于32GB的情况下,UseCompressedOops是默认开启的,该参数表示开启指针压缩,会将原来64位的指针压缩为32位。
-XX:+UseCompressedClassPointers //开启压缩类指针
-XX:-UseCompressedClassPointers //关闭压缩类指针

这个JVM参数依赖UseCompressedOops这个参数,UseCompressedOops开启,UseCompressedClassPointers默认开启,可手工关闭,UseCompressedOops关闭,UseCompressedClassPointers不管开启还是关闭都不生效即不压缩。

数组长度

如果对象是普通对象非数组对象,则没有这部分,不占用空间。
如果对象是一个数组,则将数组的长度存到对象头里,表示数组的大小。

对象体

对象体里放的是非静态的属性,也包括父类的所有非静态属性(private修饰的也在这里,不区分可见性修饰符),基本类型的属性存放的是具体的值,引用类型及数组类型存放的是引用指针。

对齐填充

虚拟机为了高效寻址,采用8字节对齐,所以对象大小不是8的倍数时,会补齐对应的位置,比如对象头+对象体是32字节时,则不需要对齐填充,对象头+对象体是12字节时,则需补齐4位。

对象大小的计算

对象的大小跟指针压缩是否开启有关,可通过以下两个参数控制。
UseCompressedClassPointers:压缩类指针(开启时类指针占4字节,关闭时类指针占8字节)
UseCompressedOops:压缩普通对象指针(开启时引用对象指针占4字节,关闭时引用对象指针占8字节)
这两个参数默认是开启的,即-XX:+UseCompressedClassPointers,-XX:+UseCompressedOops,也可手动设置,如下所示

-XX:+UseCompressedClassPointers //开启压缩类指针
-XX:-UseCompressedClassPointers //关闭压缩类指针
-XX:+UseCompressedOops  //开启压缩普通对象指针
-XX:-UseCompressedOops  //关闭压缩普通对象指针

32位HotSpot VM是不支持UseCompressedOops参数的,只有64位HotSpot VM才支持。
Oracle JDK从6 update 23开始在64位系统上会默认开启压缩指针。

以下表格展示了对象中各部分所占空间大小,单位:字节。

类型 所属部分 占用空间大小(压缩开启) 占用空间大小(压缩关闭)
Markwork 对象头 8 8
类型指针 对象头 4 8
数组长度 对象头 4 4
byte 对象体 1 1
boolean 对象体 1 1
short 对象体 2 2
char 对象体 2 2
int 对象体 4 4
float 对象体 4 4
long 对象体 8 8
double 对象体 8 8
对象引用指针 对象体 4 8
对齐填充 对齐填充 对象头+对象体是8的倍数?0 :8 -(对象头+对象体)% 8 对象头+对象体是8的倍数?0 :8 -(对象头+对象体)% 8

对象大小计算公式
对象大小=对象头 + 对象体(对象是数组时,对象体的大小=引用指针占用空间大小*对象个数) + 对齐填充
64位操作系统32G内存以下,默认开启对象指针压缩,对象头是12字节,关闭指针压缩,对象头是16字节。内存超过32G时,则自动关闭指针压缩,对象头占16字节。

对象分析

有了以上的理论知识,我们通过实际案例进行对象分析。
使用 JOL 工具分析 Java 对象大小
maven依赖

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

常用类及方法
查看对象内部信息: ClassLayout.parseInstance(obj).toPrintable()
查看对象外部信息:GraphLayout.parseInstance(obj).toPrintable()
查看对象占用空间总大小:GraphLayout.parseInstance(obj).totalSize()
查看类内部信息:ClassLayout.parseClass(Object.class).toPrintable()

使用到的测试类:

@Setter
class Goods {
    private byte b;
    private char type;
    private short age;
    private int no;
    private float weight;
    private double price;
    private long id;
    private boolean flag;
    private String goodsName;
    private LocalDateTime produceTime;
    private String[] tags;
    public static String str;
    public static int temp;
}

非数组对象,开启指针压缩

64位JVM,堆内存小于32G的情况下,默认是开启指针压缩的。

public static void main(String[] args) {
    Goods goods = new Goods();
    goods.setAge((short) 10);
    goods.setNo(123456);
    goods.setId(111L);
    goods.setGoodsName("方便面");
    goods.setFlag(true);
    goods.setB((byte)1);
    goods.setPrice(1.5d);
    goods.setProduceTime(LocalDateTime.now());
    goods.setType('A');
    goods.setWeight(0.065f);
    goods.setTags(new String[] {"food", "convenience", "cheap"});
    Goods.str = "test";
    Goods.temp = 222;
    System.out.println(ClassLayout.parseInstance(goods).toPrintable());
}

计算对象大小:
先不看输出结果,按上面的公式计算一下对象的大小:
对象头:8字节(Markword)+4字节(类指针)=12字节
对象体:1字节(属性b)+ 2字节(属性type)+ 2字节(属性age)+ 4字节(属性no)+ 4字节(属性weight)+ 8字节(属性price)+ 8字节(属性id)+ 1字节(属性flag) + 4字节(属性goodsName指针) + 4字节(属性produceTime指针) + 4字节(属性tags指针)= 42字节(注意:静态属性不参与对象大小计算)
对齐填充:8 -(对象头+对象体)% 8 = 8 - (12 + 42) % 8 = 2字节
对象大小=对象头 + 对象体 + 对齐填充 = 12字节 + 42字节 + 2字节 = 56字节。
执行看运行结果:

com.star95.study.jvm.Goods object internals:
OFF  SZ                      TYPE DESCRIPTION               VALUE
  0   8                           (object header: mark)     0x0000000000000001 (non-biasable; age: 0)
  8   4                           (object header: class)    0x2000c043
 12   4                       int Goods.no                  123456
 16   8                    double Goods.price               1.5
 24   8                      long Goods.id                  111
 32   4                     float Goods.weight              0.065
 36   2                      char Goods.type                A
 38   2                     short Goods.age                 10
 40   1                      byte Goods.b                   1
 41   1                   boolean Goods.flag                true
 42   2                           (alignment/padding gap)   
 44   4          java.lang.String Goods.goodsName           (object)
 48   4   java.time.LocalDateTime Goods.produceTime         (object)
 52   4        java.lang.String[] Goods.tags                [(object), (object), (object)]
Instance size: 56 bytes
Space losses: 2 bytes internal + 0 bytes external = 2 bytes total

这里有一个特殊的地方,打印输出的属性顺序跟代码里的顺序不一致,这是因为JVM进行优化,也就是指令重排序,会根据属性类型的大小、执行的先后顺序对结果是否有影响、最小填充大小等因素计算出对象最小应占用的空间。

非数组对象,关闭指针压缩

计算对象大小:
关闭压缩指针,类指针和引用对象指针都占8字节,推算一下对象大小:
对象头:8字节(Markword)+8字节(类指针)=16字节
对象体:1字节(属性b)+ 2字节(属性type)+ 2字节(属性age)+ 4字节(属性no)+ 4字节(属性weight)+ 8字节(属性price)+ 8字节(属性id)+ 1字节(属性flag) + 8字节(属性goodsName指针) + 8字节(属性produceTime指针) + 8字节(属性tags指针)= 54字节(注意:静态属性不参与对象大小计算)
对齐填充:8 -(对象头+对象体)% 8 = 8 - (16 + 54) % 8 = 2字节
对象大小=对象头 + 对象体 + 对齐填充 = 16字节 + 54字节 + 2字节 = 72字节。
运行时增加JVM参数如下:

-XX:-UseCompressedClassPointers -XX:-UseCompressedOops
public class ObjectLayOut1 {
    public static void main(String[] args) {
        Goods goods = new Goods();
        goods.setAge((short) 10);
        goods.setNo(123456);
        goods.setId(111L);
        goods.setGoodsName("方便面");
        goods.setFlag(true);
        goods.setB((byte)1);
        goods.setPrice(1.5d);
        goods.setProduceTime(LocalDateTime.now());
        goods.setType('A');
        goods.setWeight(0.065f);
        goods.setTags(new String[] {"food", "convenience", "cheap"});
        Goods.str = "test";
        Goods.temp = 222;
        System.out.println(ClassLayout.parseInstance(goods).toPrintable());
    }
}

执行看运行结果:

com.star95.study.jvm.Goods object internals:
OFF  SZ                      TYPE DESCRIPTION               VALUE
  0   8                           (object header: mark)     0x0000000000000001 (non-biasable; age: 0)
  8   8                           (object header: class)    0x00000000175647b8
 16   8                    double Goods.price               1.5
 24   8                      long Goods.id                  111
 32   4                       int Goods.no                  123456
 36   4                     float Goods.weight              0.065
 40   2                      char Goods.type                A
 42   2                     short Goods.age                 10
 44   1                      byte Goods.b                   1
 45   1                   boolean Goods.flag                true
 46   2                           (alignment/padding gap)   
 48   8          java.lang.String Goods.goodsName           (object)
 56   8   java.time.LocalDateTime Goods.produceTime         (object)
 64   8        java.lang.String[] Goods.tags                [(object), (object), (object)]
Instance size: 72 bytes
Space losses: 2 bytes internal + 0 bytes external = 2 bytes total

数组对象开启指针压缩

计算对象大小:
默认是开启压缩指针的,类指针和引用对象指针都占4字节,推算一下对象大小:
对象头:8字节(Markword)+ 4字节(类指针) + 4字节(数组长度)= 16字节
对象体:4字节 * 3 = 12字节
对齐填充:8 -(对象头+对象体)% 8 = 8 - (16字节 + 12字节)% 8= 4字节
对象大小=对象头 + 对象体 + 对齐填充 = 16字节 + 12字节 + 4字节 = 32字节。

public class ObjectLayOut1 {
    public static void main(String[] args) {
        Goods goods = new Goods();
        goods.setAge((short) 10);
        goods.setNo(123456);
        goods.setId(111L);
        goods.setGoodsName("方便面");
        goods.setFlag(true);
        goods.setB((byte)1);
        goods.setPrice(1.5d);
        goods.setProduceTime(LocalDateTime.now());
        goods.setType('A');
        goods.setWeight(0.065f);
        goods.setTags(new String[] {"food", "convenience", "cheap"});
        Goods.str = "test";
        Goods.temp = 222;
        Goods[] goodsArr = new Goods[3];
        goodsArr[0] = goods;
        System.out.println(ClassLayout.parseInstance(goodsArr).toPrintable());
    }
}

执行看运行结果:

[Lcom.star95.study.jvm.Goods; object internals:
OFF  SZ                         TYPE DESCRIPTION               VALUE
  0   8                              (object header: mark)     0x0000000000000001 (non-biasable; age: 0)
  8   4                              (object header: class)    0x2000c18d
 12   4                              (array length)            3
 16  12   com.star95.study.jvm.Goods Goods;.<elements>         N/A
 28   4                              (object alignment gap)    
Instance size: 32 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

数组对象关闭指针压缩

计算对象大小:
关闭压缩指针,类指针和引用对象指针都占8字节,推算一下对象大小:
对象头:8字节(Markword)+8字节(类指针) + 4字节(数组长度)=20字节
对象体:8字节 * 3 = 24字节
对齐填充:8 -(对象头+对象体)% 8 = 8 - (20+ 24) % 8 = 4字节
对象大小=对象头 + 对象体 + 对齐填充 = 20字节 + 24字节 + 4字节 = 48字节。
运行时增加JVM参数如下:

-XX:-UseCompressedClassPointers -XX:-UseCompressedOops
public class ObjectLayOut1 {
    public static void main(String[] args) {
        Goods goods = new Goods();
        goods.setAge((short) 10);
        goods.setNo(123456);
        goods.setId(111L);
        goods.setGoodsName("方便面");
        goods.setFlag(true);
        goods.setB((byte)1);
        goods.setPrice(1.5d);
        goods.setProduceTime(LocalDateTime.now());
        goods.setType('A');
        goods.setWeight(0.065f);
        goods.setTags(new String[] {"food", "convenience", "cheap"});
        Goods.str = "test";
        Goods.temp = 222;
        Goods[] goodsArr = new Goods[3];
        goodsArr[0] = goods;
        System.out.println(ClassLayout.parseInstance(goodsArr).toPrintable());
    }
}

执行看运行结果:

[Lcom.star95.study.jvm.Goods; object internals:
OFF  SZ                         TYPE DESCRIPTION               VALUE
  0   8                              (object header: mark)     0x0000000000000001 (non-biasable; age: 0)
  8   8                              (object header: class)    0x0000000017e04d70
 16   4                              (array length)            3
 20   4                              (alignment/padding gap)   
 24  24   com.star95.study.jvm.Goods Goods;.<elements>         N/A
Instance size: 48 bytes
Space losses: 4 bytes internal + 0 bytes external = 4 bytes total

通过以上对象分析,我们看到在开启压缩指针的情况下,对象的大小会小很多,节省了内存空间。

总结

通过以上的分析,基本已经把java对象的结构讲清楚了,另外对象占用内存空间大小也计算出来,有助于进行JVM调优分析,64位的虚拟机内存在32G以下时默认是开启压缩指针的,超过32G自动关闭压缩指针,主要目的都是为了提高寻址效率。
另外,本文是通过JOL工具计算对象占用空间的大小,不包括引用对象实际占用的内存大小,因为计算时是按引用对象的指针占用空间大小计算的,可能跟其他工具计算的结果不一样,具体跟工具的计算逻辑有关,比如跟JDK自带的jvisualvm工具通过堆dump出来看到的对象大小不一样,感兴趣的可自行验证。

热门相关:恭喜你被逮捕了   聚会的目的:开始   小姐   性瘾:偷窥狂   锦乡里