Eric's Blogs

Better Code, Better Life

0%

如何正确计算Java对象所占内存？

发表于 分类于
本文字数： 5.1k 阅读时长 ≈ 5 分钟

Java应用上线前，常常需要估算所需的内存，从而设置正确的内存选项参数。正确计算Java对象所占内存从而估算应用的整体所占内存，就显得很有必要。那么，如何计算Java对象所占的内存呢？

1.Java对象的内存布局

计算Java对象所占内存，首先需要了解Java对象的内存布局。一个Java对象在内存中可以分为三部分：对象头、实例数据和对齐填充。关于对象头的详细介绍可查看这篇文章；实例数据即Java的成员字段，包括基本类型和对象引用；对齐填充并不必须存在，只用作占位对齐字节。一个对象的内存布局示意如下：

1
2
3
4
5
|---------------------------|-----------------|---------|
|       Object Header       |  Instance Data  | Padding |
|-----------|---------------|-----------------|---------|
| Mark Word | Klass Pointer | field1|filed2|  | Padding |
|-----------|---------------|-----------------|---------|

需要注意以下几点：

  1. 对象默认以8字节对齐，即对象所占空间必须是8的整数倍。默认对齐字节数可以使用选项-XX:ObjectAlignmentInBytes=num设置，最小值为8，最大值为256。
  2. 为了避免空间浪费，实例数据会进行重排序，排序的优先级为： long = double > int = float > char = short > byte > boolean > object reference。
  3. 继承体系里不同类的字段不会混合在一起，父类成员字段分配之后才会分配子类，每个类里的字段遵循第2条规则。
  4. 继承体系里不同类间需要8字节对齐。
  5. 在继承体系中，父类层次中有至少4字节的空闲而子类含有4字节及其以下的字段，将按优先级：int = float > char = short > byte > boolean > object reference填充这4字节。对象头部如果有剩余也会使用该规则填充。

2.内存布局实例研究

为了方便的研究对象所占的内存，建议使用官方提供的jol工具，如果使用Maven，只需加入如下依赖：

1
2
3
4
5
<dependency>
    <groupId>org.openjdk.jol</groupId>
    <artifactId>jol-core</artifactId>
    <version>0.9</version>
</dependency>

然后便可以愉快的查看内存布局了：

1
2
3
4
public static void main(String[] args) {
    System.out.println(ClassLayout.parseClass(Object.class).toPrintable());
    System.out.println(ClassLayout.parseInstance(new Integer(1)).toPrintable());
}

上述代码第一行的输出如下（JDK8 64 bit）：

1
2
3
4
5
6
java.lang.Object object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0    12        (object header)                           N/A
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

由于目前的计算机基本为64位架构，所以忽略32位JVM，只对64位进行讨论。由于JDK8以后默认开启-XX:CompressedOops选项，所以上述为开启指针压缩的结果。

2.1 int VS Integer

Java中，一个int占4个字节，那么Integer对象占多少字节呢？Integer对象中只有一个value字段用于存储实际的整数。不开启指针压缩时，其布局为：

1
2
3
4
5
|-------------------------------------------|----------------|-----------------|
|                Object Header              |  Instance Data |      Padding    |
|-------------------|-----------------------|----------------|-----------------|
| Mark Word(8 byte) | Klass Pointer(8 byte) |  value(4 byte) | Padding(4 byte) |
|-------------------|-----------------------|----------------|-----------------|

开启指针压缩时，内存布局为：

1
2
3
4
5
|-------------------------------------------|----------------|
|                Object Header              |  Instance Data |
|-------------------|-----------------------|----------------|
| Mark Word(8 byte) | Klass Pointer(4 byte) |  value(4 byte) |
|-------------------|-----------------------|----------------|

可知如果不开启指针压缩，一个Integer对象需要占用24字节，就算开启指针压缩也需要占用16字节，是int的四倍多。Integer的内存占用超出想象，由此在Java中产生了许多优化方案。考虑Java集合，其中的对象泛型不支持基本数据类型，而只能使用Integer，Long等包装器类，这样将会耗费过多的内存。为了节约内存，一些开源工具支持基本类型的容器，比如：Koloboke。

2.2 字段重排序

为了更高效的使用内存，实例数据字段将会重排序。排序的优先级为： long = double > int = float > char = short > byte > boolean > object reference。如下所示的类：

1
2
3
4
5
6
7
class FieldTest{
    byte a;
    int c;
    boolean d;
    long e;
    Object f;
}

将会重排序为（开启CompressedOops选项）：

1
2
3
4
5
6
7
OFFSET  SIZE               TYPE DESCRIPTION            
    16     8               long FieldTest.e            
    24     4                int FieldTest.c            
    28     1               byte FieldTest.a            
    29     1            boolean FieldTest.d            
    30     2              (alignment/padding gap)
    32     8   java.lang.Object FieldTest.f

2.3 继承体系的布局

继承体系中，类间不混排，而是独立分隔开，但每个类中的字段遵循前述的优先级。如下的类：

1
2
3
4
5
6
7
8
9
class Father {
    int a;
    int b;
    long c;
}

class Child extends Father {
    long d;
}

重排序的结果为：

1
2
3
4
5
OFFSET  SIZE   TYPE DESCRIPTION    
    16     8   long Father.c       
    24     4    int Father.a       
    28     4    int Father.b       
    32     8   long Child.d

不开启指针压缩时，如果继承体系中的类字段没有占满8字节，将补齐字节对齐8字节。如下的类：

1
2
3
4
5
6
7
8
9
10
class Father {
    long a;
    byte b;
    byte c;
}

class Child extends Father {
    long d;
    byte e;
}

重排序的结果为：

1
2
3
4
5
6
7
8
OFFSET  SIZE   TYPE DESCRIPTION            
    16     8   long Father.a               
    24     1   byte Father.b               
    25     1   byte Father.c               
    26     6        (alignment/padding gap)
    32     8   long Child.d                
    40     1   byte Child.e                
    41     7        (alignment/padding gap)

开启指针压缩时，情况稍有不同：如果父类层次中有至少4字节的空闲，则子类中如果含有4字节及其以下的字段，将按优先级：int = float > char = short > byte > boolean > object reference填充。开启指针压缩时，由于对象头只有12字节，剩余的4字节也将按这样的规则填充。如下的类：

1
2
3
4
5
6
7
8
9
10
class Father {
    byte b;
    long a;
    byte c;
}

class Child extends Father {
    byte e;
    long d;
}

重排序的结果为：

1
2
3
4
5
6
7
8
OFFSET  SIZE   TYPE DESCRIPTION                             
    12     1   byte Father.b                                
    13     1   byte Father.c                                
    14     2        (alignment/padding gap)                 
    16     8   long Father.a                                
    24     8   long Child.d                                 
    32     1   byte Child.e                                 
    33     7        (alignment)

2.4 非静态内部类

非静态内部类隐含一个指向外部类对象的引用，如下的类：

1
2
3
4
5
6
7
8
class Outer {
    int a;
    Inner i;

    class Inner{
        int b;
    }
}

其中Inner的字段排序结果为：

1
2
3
4
5
OFFSET  SIZE    TYPE DESCRIPTION      
    0    12         (object header)        
    12     4     int Inner.b                                  
    16     4   Outer Inner.this$0                             
    20     4         (loss due to the next object alignment)

可见其中的隐含引用，这也就是能使用Inner.this引用外部对象的原因。

3.估算应用所占内存

明白了这些，那么估算应用所占内存便成为可能。一个应用使用如下的数据结构存储数据：

1
HashMap<Integer, String> cache = new HashMap<Integer, String>();

该应用有约100万数据，其中每个String的长度约为50，该应用大约占用多少内存呢？假设该应用运行在64位JVM上，开启CompressedOops选项。

由前述分析知：一个Integer占用16字节。那么长度为50的字符串占用多少字节呢？String的数据结构如下：

1
2
3
4
public final class String {
    private int hash; // Default to 1
    private final char value[];
}

其中含有一个int值和字符数组，而数组的对象头中含有一个4字节的长度字段，故对象头部为16字节。该String对象的内存布局示意如下：

img

字符串内存布局示意

可知，长度为50的字符串占用24+120=144字节的空间。
估计HashMap大小的关键是估算Entry的大小，它的数据结构如下：

1
2
3
4
5
6
static class Entry<K,V> implements Map.Entry<K,V> {
    final K key;    // 引用
    V value;    // 引用
    Entry<K,V> next; // 引用
    int hash;
}

可知一个Entry所占内存为：12B对象头+16B实例数据+4B对齐填充，共占用32字节。由于含有100万条数据，故将创建100万个Entry。由此可估算所占内存为：100万Integer、100万String和100万Entry，忽略HashMap的其他小额占用，最终占用内存：

1
(16 + 144 + 32) * 1 000 000 ≈ 192 MB

使用visual vm工具进行监控的实际数据如下：

img

应用所占内存示意

附相关资料：

Java对象结构及大小计算
Java Object Memory Structure
Java数据对齐讨论
jdk jol工具

本文整理自

如何正确计算Java对象所占内存？

仅做个人学习总结所用,遵循CC 4.0 BY-SA版权协议,如有侵权请联系删除!