如何正确计算Java对象所占内存?
Java应用上线前,常常需要估算所需的内存,从而设置正确的内存选项参数。正确计算Java对象所占内存从而估算应用的整体所占内存,就显得很有必要。那么,如何计算Java对象所占的内存呢?
1.Java对象的内存布局
计算Java对象所占内存,首先需要了解Java对象的内存布局。一个Java对象在内存中可以分为三部分:对象头、实例数据和对齐填充。关于对象头的详细介绍可查看这篇文章;实例数据即Java的成员字段,包括基本类型和对象引用;对齐填充并不必须存在,只用作占位对齐字节。一个对象的内存布局示意如下:
|---------------------------|-----------------|---------|
| Object Header | Instance Data | Padding |
|-----------|---------------|-----------------|---------|
| Mark Word | Klass Pointer | field1|filed2| | Padding |
|-----------|---------------|-----------------|---------|
需要注意以下几点:
- 对象默认以8字节对齐,即对象所占空间必须是8的整数倍。默认对齐字节数可以使用选项-XX:ObjectAlignmentInBytes=num设置,最小值为8,最大值为256。
- 为了避免空间浪费,实例数据会进行重排序,排序的优先级为: long = double > int = float > char = short > byte > boolean > object reference。
- 继承体系里不同类的字段不会混合在一起,父类成员字段分配之后才会分配子类,每个类里的字段遵循第2条规则。
- 继承体系里不同类间需要8字节对齐。
- 在继承体系中,父类层次中有至少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集合,其中的对象泛型不支持基本数据类型,而只能使用Integer
,Long
等包装器类,这样将会耗费过多的内存。为了节约内存,一些开源工具支持基本类型的容器,比如: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工具