1 对象内存大小度量
补充了文中的细节,做了一些订正,加粗斜体是补充和订正
在做内存优化时,需要知道每个对象占用的内存的大小,
一个实例化的对象在内存中需要存储的信息包括:
1. 对象的头部(对象的GC信息,hash值,类定义引用等)
2. 对象的成员变量:包括基本数据类型和引用。如成员变量是一个引用,引用了其他对象,被引用的对象内存另外计算。
如下一个简单的类的定义:
class MyClass {
int a;
Object object;
}
1.1 实例化一个对象
MyClass myClass = new MyClass();
对象大小分为:
1.1.1自身的大小(Shadow heap size):
直接计算当前对象占用空间大小,包括当前类及超类的基本类型实例字段大小、引用类型实例字段引用大小、实例基本类型数组总占用空间、实例引用类型数组引用本身占用空间大小
1.1.2所引用的对象的大小(Retained heap size):
myClass实例创建出来之后,在内存中所占的大小就是myClass自身大小(Shadow heap size)。包括类的头部大小以及一个int的大小和一个引用的大小。
myClass 中object 成员变量是一个对象引用,这个被引用的对象也占一定大小。myClass实例所维护的引用的对象所占的大小,称为myClass实例的Retained heap size。
本文讨论的是对象自身的大小,即Shadow heap size。Retained heap size递归计算即可得。
2度量工具
对象大小的计算可用java.lang.instrument.Instrumentation 或者 dump内存之后用memory analyzer分析。这是一份示例代码java-object-size
2.1基本数据类型大小
基本数据类型大小如下: From WIKI
type | size(bits) | bytes |
boolean | 8 | 1 |
byte | 8 | 1 |
char | 16 | 2 |
short | 16 | 2 |
int | 32 | 4 |
long | 64 | 8 |
float | 32 | 4 |
double | 64 | 8 |
2.2引用的大小
在32位的JVM上,一个对象引用占用4个字节;在64位上,占用8个字节。通过 java -d64 -version可确定是否是64位的JVM。
使用8个字节是为了能够管理大于4G的内存,如果你的程序不需要访问大于4G的内存,
可通过-XX:+UseCompressedOops选项,开启指针压缩。从Java 1.6.0_23起,这个选项默认是开的。可通过jinfo -flag UseCompressedOops <pid>查看。
localhost:~ srain$ jinfo -flag UseCompressedOops 13133
-XX:+UseCompressedOops
2.3对象头部的大小
对象头,结构如下:
+------------------+------------------+------------------+---------------.
| mark word | klass pointer | array size (opt) | padding |
+------------------+------------------+-------------------+---------------'
每个对象都有一个mark work头部,以及一个引用,指向类的信息。在32位JVM上,markword 4个字节,整个头部有8字节大小。
array size(opt)在对象为数组的时候启用,4字节(4byte)长度。JVM规定对象头(Object Header)长度为2个字(word),在32bit JVM中,一个word长度为4byte,64bit JVM中,长度为8byte
在未开启UseCompressedOops的64位JVM上,对象头有16字节大小。
在开启UseCompressedOops的64位机器上,引用(klass pointer)成了4字节,一共12字节。按照8位对齐,实际占用16字节。
java在64bit模式下开启指针压缩,比32bit模式下,头部会大4byte(_mark区域变成8byte,_class区域被压缩),如果没有开启指针压缩,头部会大8byte(_mark和_class都会变成8byte),jdk1.6推出参数-XX:+UseCompressedOops,在32G内存一下默认会自动打开这个参数,如下:
[Nathan@laptop ~]$ java -Xmx31g -XX:+PrintFlagsFinal |grep Compress
true
true
false
[Nathan@laptop ~]$ java -Xmx32g -XX:+PrintFlagsFinal |grep Compress
true
false
false
3对象的内存布局
1. 每个对象的内存占用按8字节对齐
2. 空对象和类实例成员变量
空对象,指的非inner-class,没有实例属性的类。Object 类或者直接继承Object 没有添加任何实例成员的类,即:new Object() 。
空对象的不包含任何成员变量,其大小即对象头大小:
o 在32位JVM上,占用8字节;
o 在开启UseCompressedOops的64位JVM上,12 + 4 = 16;
o 订正:在开启UseCompressedOops的64位JVM上,object header长度为12(mark word: 8, kclass pointer: 4),padding为4,对齐后的长度为16;
o 在未开启UseCompressedOops的64位JVM上,16 + 4 = 20; 对齐后为24。
o 订正:在未开启UseCompressedOops的64位JVM上,长度16(mark word:8 ,klass pointer 8)。
3. 对象实例成员重排序
实例成员变量紧随对象头。每个成员变量都尽量使本身的大小在内存中尽量对齐。
比如int按4位对齐,long按8位对齐。为了内存紧凑,实例成员在内存中的排列和声明的顺序可能不一致,实际会按以下顺序排序:
1. doubles andlongs
2. ints and floats
3. shorts andchars
4. booleans andbytes
5. references
这样做可尽量节省空间。
如:
classMyClass{
byte a;
int c;
boolean d;
long e;
Object f;
}
未重排之前:
32 bit 64bit +UseCompressedOops
[HEADER: 12 bytes] 8 [HEADER: 12 bytes] 12
[a: 1 byte ] 9 [a: 1 byte ] 13
[padding: 3 bytes] 12 [padding: 3 bytes] 16
[c: 4 bytes] 16 [c: 4 bytes] 20
[d: 1 byte ] 17 [d: 1 byte ] 21
[padding: 7 bytes] 24 [padding: 3 bytes] 24
[e: 8 bytes] 32 [e: 8 bytes] 32
[f: 4 bytes] 36 [f: 4 bytes] 36
[padding: 4 bytes] 40 [padding: 4 bytes] 40
重新排列之后:
32 bit 64bit +UseCompressedOops
[HEADER: 8 bytes] 8 [HEADER: 12 bytes] 12
[e: 8 bytes] 16 [e: 8 bytes] 20
[c: 4 bytes] 20 [c: 4 bytes] 24
[a: 1 byte ] 21 [a: 1 byte ] 25
[d: 1 byte ] 22 [d: 1 byte ] 26
[padding: 2 bytes] 24 [padding: 2 bytes] 28
[f: 4 bytes] 28 [f: 4 bytes] 32
[padding: 4 bytes] 32
4. 父类和子类的实例成员
父类和子类的成员变量分开存放,先是父类的实例成员。父类实例成员变量结束之后,按4位对齐,随后接着子类实例成员变量。
classA{
byte a;
}
classBextends A{
byte b;
}
内存结构如下:
32 bit 64bit +UseCompressedOops
[HEADER: 8 bytes] 8 [HEADER: 12 bytes] 12
[a: 1 byte ] 9 [a: 1 byte ] 13
[padding: 3 bytes] 12 [padding: 3 bytes] 16
[b: 1 byte ] 13 [b: 1 byte ] 17
[padding: 3 bytes] 16 [padding: 7 bytes] 24
如果子类首个成员变量是long或者double等8字节数据类型,而父类结束时没有8位对齐。会把子类的小于8字节的实例成员先排列,直到能8字节对齐。
class A {
byte a;
}
class B extends A{
long b;
short c;
byte d;
}
内存结构如下:
32 bit 64bit +UseCompressedOops
[HEADER: 8 bytes] 8 [HEADER: 8 bytes] 12
[a: 1 byte ] 9 [a: 1 byte ] 13
[padding: 3 bytes] 12 [padding: 3 bytes] 16
[c: 2 bytes] 14 [b: 8 bytes] 24
[d: 1 byte ] 15 [c: 4 byte ] 28
[padding: 1 byte ] 16 [d: 1 byte ] 29
[b: 8 bytes] 24 [padding: 3 bytes] 32
上面的示例中,在32位的JVM上,B的2个实例成员c, d被提前了。
5. 非静态的内部类,有一个隐藏的对外部类的引用。
3.1数组的内存占用大小
数组也是对象,故有对象的头部,另外数组还有一个记录数组长度的int类型,随后是每一个数组的元素:基本数据类型或者引用。8字节对齐。
32 位的机器上
byte[0] 8字节的对象头部,4字节的int长度, 12字节,对齐后是16字节,实际 byte[0] ~byte[4]都是16字节(每个byte的长度为1byte,byte[0]-byte[4]占用padding长度)。
64 位+UseCompressedOops
byte[0] 是16字节大小(对象头:mark word: 8byte, kclasspointer: 4byte, array sizeof: 4byte),byte[1] ~byte[8] 24字节大小。
64 位-UseCompressedOops
byte[0], 16字节头部,4字节的int长度信息,20字节,对齐后 24 字节。byte[0] ~ byte[4] 都是24字节。
计算一个数组对象的公式(-XX:UseCompressedOops)
The general rules forcomputing the size of an object on JVM are :
32 bit
Arrays of boolean, byte, char, short, int: 2 * 4 (Object header)+ 4 (length-field) + sizeof(primitiveType) * length -> align result up to amultiple of 8
Arrays of objects: 2 * 4 (Object header) + 4 (length-field) + 4(objectreference length) * array length -> align result up to a multiple of 8
Arrays of longs and doubles: 2 * 4 (Object header) + 4 (length-field) + 4 (deadspace due to alignment restrictions) + 8 * length
java.lang.Object: 2 * 4 (Object header)
other objects: sizeofSuperClass + 8 * nrOfLongAndDoubleFields + 4 *nrOfIntFloatAndObjectFields + 2 * nrOfShortAndCharFields + 1 *nrOfByteAndBooleanFields -> align result up to a multiple of 8
64 bit
Arrays of boolean, byte, char, short, int: 2 * 8 (Object header)+ 4 (length-field) + sizeof(primitiveType) * length -> align result up to amultiple of 8
Arrays of objects: 2 * 8 (Object header) + 4 (length-field) + 4 (dead space dueto alignment restrictions) + 8 * length
Arrays of longs and doubles: 2 * 8 (Object header) + 4 (length-field) + 4 (deadspace due to alignment restrictions) + 8 * length
java.lang.Object: 2 * 8 (Object header)
other objects: sizeofSuperClass + 8 * nrOfLongDoubleAndObjectFields + 4 +nrOfntAndFloatFields + 2 * nrOfShortAndCharFields + 1 *nrOfByteAndBooleanFields -> align result up to a multiple of 8
Note thatan object might have unused space due to alignment at every inheritance level(e.g. imagine a class A with just a byte field and class B has A as it'ssuperclass and declares a byte field itself -> 14 bytes 'wasted on 64 bitsystem).
Inpractice 64 bit needs 30 to 50% more memory due to references being twice aslarge.
3.2字符串大小
Field | Type | 64 bit -UseCompressedOops | 64 bit +UseCompressedOops | 32 bit |
HEADER | 无 | 16 | 12 | 8 |
value | char[] | 8(引用) | 4 | 4 |
offset | int | 4 | 4 | 4 |
count | int | 4 | 4 | 4 |
hash | int | 4 | 4 | 4 |
PADDING | 无 | 4 | 4 | 0 |
TOTAL | 无 | 40 | 32 | 24 |
不计算value引用的Retained heap size,字符串本身就需要 24 ~ 40字节大小。
一个newString("a");+UseCompressedOops这个对象的空间大小为:12字节头部+4*4 = 28字节对齐到32字节,然后value所指向的char数组头部比普通对象多4个byte来存放长度,12+4+2byte的字符=18,总大小为28+18=46byte,对齐后就是48byte,其实即使你new String()也会占这么大的空间,28+16=44byte,因为有对齐,如果字符的长度是8个,那么就是12+4+16=32,也就是有64byte;
如果不开启指针压缩再算算:头部变成16byte + 4*3个int数据 + 8(1个指针) = 36对齐到40byte,对应的char数组的头部变成16+4 + 2 = 22对齐到24byte,40+24=64byte,也就是只有一个字符或者0个字符都会对齐到64byte,所以,你懂的,参数该怎么调,代码该怎么写,如果长度为8个字符的那么后面部分就会变成16+4+16=36对齐到40byte,40+40=80byte,也就是说,抛开其他的引用空间(比如通过数组或集合类引用),如果你有10来个String,每个大小就装8个字符,就会有1K的大小
4参考资料
http://kohlerm.blogspot.com/2008/12/how-much-memory-is-used-by-my-java.html
http://www.liaohuqiu.net/cn/posts/caculate-object-size-in-java/
http://yueyemaitian.iteye.com/blog/2033046