Java 杂谈jvm

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

2018-04-29  本文已影响835人  Hypercube

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

1.Java对象的内存布局

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

|---------------------------|-----------------|---------|
|       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,只需加入如下依赖:

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

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

    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):

    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字段用于存储实际的整数。不开启指针压缩时,其布局为:

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

开启指针压缩时,内存布局为:

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

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

2.2 字段重排序

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

    class FieldTest{
        byte a;
        int c;
        boolean d;
        long e;
        Object f;
    }

将会重排序为(开启CompressedOops选项):

     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 继承体系的布局

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

    class Father {
        int a;
        int b;
        long c;
    }
    
    class Child extends Father {
        long d;
    }

重排序的结果为:

     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字节。如下的类:

    class Father {
        long a;
        byte b;
        byte c;
    }
    
    class Child extends Father {
        long d;
        byte e;
    }

重排序的结果为:

     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字节也将按这样的规则填充。如下的类:

    class Father {
        byte b;
        long a;
        byte c;
    }
    
    class Child extends Father {
        byte e;
        long d;
    }

重排序的结果为:

     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 非静态内部类

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

    class Outer {
        int a;
        Inner i;
    
        class Inner{
            int b;
        }
    }

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

 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.估算应用所占内存

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

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

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

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

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

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

字符串内存布局示意
可知,长度为50的字符串占用24+120=144字节的空间。
估计HashMap大小的关键是估算Entry的大小,它的数据结构如下:
    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的其他小额占用,最终占用内存:

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

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


应用所占内存示意

附相关资料:

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

上一篇下一篇

猜你喜欢

热点阅读