Java 对象内存占用和对象头分析

前言

普通对象的内存布局：

1）Mark Word， 8个字节
2）Class Pointer，如果是 32G 内存以下的，默认开启对象指针压缩，4 个字节
3）数据区
4）Padding(内存对齐)，按照 8 的倍数对齐

数组对象的内存布局：

1）Mark Word， 8个字节
2）Class Pointer，如果是 32G 内存以下的，默认开启对象指针压缩，4个字节
3）数组长度，4 个字节
4）数据区
5）Padding(内存对齐)，按照 8 的倍数对齐

对象的内存布局

原生类型内存占用如下图所示：

原生类型占用内存

RamUsageEstimator（计算 Java 对象内存占用）

简介

RamUsageEstimator 是根据 Java 对象在堆内存中的存储格式，通过计算 Java 对象头、实例数据、引用等的大小，相加而得，如果有引用，还能递归计算引用对象的大小。

缺点：这种方式计算所得的对象头大小是基于 JVM 声明规范的，并不是通过运行时内存地址计算而得，存在与实际大小不符的这种可能性。

依赖

<!-- 计算 Java 对象内存占用工具 -->
    <dependency>
      <groupId>org.apache.lucene</groupId>
      <artifactId>lucene-core</artifactId>
      <version>4.0.0</version>
    </dependency>

常用方法 API

//计算指定对象及其引用树上的所有对象的综合大小，单位字节
long RamUsageEstimator.sizeOf(Object obj)

//计算指定对象本身在堆空间的大小，单位字节
long RamUsageEstimator.shallowSizeOf(Object obj)

//计算指定对象及其引用树上的所有对象的综合大小，返回可读的结果，如：2KB
String RamUsageEstimator.humanSizeOf(Object obj)

演示代码

sizeOf() 方法演示：

import lombok.extern.slf4j.Slf4j;
import org.apache.lucene.util.RamUsageEstimator;

@Slf4j
public class RamUsageEstimatorDemo {

    public static void main(String[] args) {
        // 12(Header) + 0(Instance Data) + 4(Padding) = 16 bytes
        log.info("sizeOf(new Object()) = {} bytes", RamUsageEstimator.sizeOf(new Object()));

        // 12(Header) + 1(Instance Data) + 3(Padding) = 16 bytes
        log.info("sizeOf(boolean) = {} bytes", RamUsageEstimator.sizeOf(true));
        log.info("sizeOf(byte) = {} bytes", RamUsageEstimator.sizeOf((byte)2));

        // 12(Header) + 2(Instance Data) + 2(Padding) = 16 bytes
        log.info("sizeOf(char) = {} bytes", RamUsageEstimator.sizeOf('c'));
        log.info("sizeOf(short) = {} bytes", RamUsageEstimator.sizeOf((short)2));


        // 12(Header) + 4(Instance Data) + 0(Padding) = 16 bytes
        log.info("sizeOf(int) = {} bytes", RamUsageEstimator.sizeOf(2));
        log.info("sizeOf(float) = {} bytes", RamUsageEstimator.sizeOf((float)2.0));

        // 12(Header) + 8(Instance Data) + 4(Padding) = 24 bytes
        log.info("sizeOf(long) = {} bytes", RamUsageEstimator.sizeOf((long)2));
        log.info("sizeOf(double) = {} bytes", RamUsageEstimator.sizeOf(2.0));

        // 16(Header) + 0(Instance Data) + 0(Padding) = 16 bytes
        log.info("sizeOf(new int[]) = {} bytes", RamUsageEstimator.sizeOf(new int[]{}));

        // 16(Header) + 4(Instance Data) + 4(Padding) = 24 bytes
        log.info("sizeOf(new int[]) = {} bytes", RamUsageEstimator.sizeOf(new int[]{2}));

        // 16(Header) + 8(Instance Data) + 0(Padding) = 24 bytes
        log.info("sizeOf(new int[]) = {} bytes", RamUsageEstimator.sizeOf(new int[]{2, 2}));
    }
}

shallowSizeOf() 方法演示：

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.lucene.util.RamUsageEstimator;

@Slf4j
public class RamUsageEstimatorReferenceDemo {

    public static void main(String[] args) {
        ReferenceData empty = new ReferenceData();
        ReferenceData full = ReferenceData.full();
        // 12(Header) + 8(Instance Data) + 4(Padding) = 24 bytes
        // 一个压缩后的对象指针占用 4 bytes，两个就是 8 bytes
        log.info("sizeOf(empty ReferenceData) = {} bytes", RamUsageEstimator.sizeOf(empty));
        log.info("humanSizeOf(empty ReferenceData) = {} bytes", RamUsageEstimator.humanSizeOf(empty));
        log.info("shallowSizeOf(empty ReferenceData) = {} bytes", RamUsageEstimator.shallowSizeOf(empty));

        System.out.println();

        // ReferenceData: 12(Header) + 8(Instance Data) + 4(Padding) = 24 bytes
        // Integer: 12(Header) + 4(Instance Data)  = 16 bytes
        // Long: 12(Header) + 8(Instance Data) + 4(Padding) = 24 bytes
        // total size = 24(ReferenceData) + 16(Integer) + 24(Long) + = 64 bytes
        log.info("sizeOf(full ReferenceData) = {} bytes", RamUsageEstimator.sizeOf(full));
        log.info("humanSizeOf(full ReferenceData) = {} bytes", RamUsageEstimator.humanSizeOf(full));


        // shallowSizeOf() 方法不会考虑字段引用对象占用的内存
        // 一个压缩后的对象指针占用 4 bytes，两个就是 8 bytes
        // 12(Header) + 8(Instance Data) + 4(Padding) = 24 bytes
        log.info("shallowSizeOf(full ReferenceData) = {} bytes", RamUsageEstimator.shallowSizeOf(full));
    }

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public static class ReferenceData {
        private Integer intVal;
        private Long longVal;

        public static ReferenceData full() {
            return new ReferenceData(2, 2L);
        }
    }
}

jol（查看对象头的神器）

简介

jol 为 java object layout 的缩写，即 Java 对象布局。
是一个可以在代码中计算 Java 对象的大小以及查看 Java 对象内存布局的工具包。

依赖

    <!-- 查看对象头的神器 -->
    <dependency>
      <groupId>org.openjdk.jol</groupId>
      <artifactId>jol-core</artifactId>
      <version>0.14</version>
    </dependency>

使用 jol 计算对象的大小

语法：

// 使用 jol 计算对象的大小（单位为字节）
ClassLayout.parseInstance(obj).instanceSize()

使用 Demo：

import lombok.extern.slf4j.Slf4j;
import org.openjdk.jol.info.ClassLayout;

@Slf4j
public class ClassLayoutDemo {

    public static void main(String[] args) {
        // 12(Header) + 0(Instance Data) + 4(Padding) = 16 bytes
        log.info("sizeOf(new Object()) = {} bytes", ClassLayout.parseInstance(new Object()).instanceSize());

        // 12(Header) + 1(Instance Data) + 3(Padding) = 16 bytes
        log.info("sizeOf(boolean) = {} bytes", ClassLayout.parseInstance(true).instanceSize());
        log.info("sizeOf(byte) = {} bytes", ClassLayout.parseInstance((byte) 2).instanceSize());

        // 12(Header) + 2(Instance Data) + 2(Padding) = 16 bytes
        log.info("sizeOf(char) = {} bytes", ClassLayout.parseInstance('c').instanceSize());
        log.info("sizeOf(short) = {} bytes", ClassLayout.parseInstance((short) 2).instanceSize());


        // 12(Header) + 4(Instance Data) + 0(Padding) = 16 bytes
        log.info("sizeOf(int) = {} bytes", ClassLayout.parseInstance(2).instanceSize());
        log.info("sizeOf(float) = {} bytes", ClassLayout.parseInstance((float) 2.0).instanceSize());

        // 12(Header) + 8(Instance Data) + 4(Padding) = 24 bytes
        log.info("sizeOf(long) = {} bytes", ClassLayout.parseInstance((long) 2).instanceSize());
        log.info("sizeOf(double) = {} bytes", ClassLayout.parseInstance(2.0).instanceSize());

        // 16(Header) + 0(Instance Data) + 0(Padding) = 16 bytes
        log.info("sizeOf(new int[]) = {} bytes", ClassLayout.parseInstance(new int[]{}).instanceSize());

        // 16(Header) + 4(Instance Data) + 4(Padding) = 24 bytes
        log.info("sizeOf(new int[]) = {} bytes", ClassLayout.parseInstance(new int[]{2}).instanceSize());

        // 16(Header) + 8(Instance Data) + 0(Padding) = 24 bytes
        log.info("sizeOf(new int[]) = {} bytes", ClassLayout.parseInstance(new int[]{2, 2}).instanceSize());
    }
}

和 RamUsageEstimator.sizeOf() 方法的结果一致。

使用 jol 查看对象的内存布局

语法：

// 使用 jol 查看对象的内存布局
ClassLayout.parseInstance(obj).toPrintable()