一个对象占用多少字节？

谁践踏了优雅 2022-06-14 03:18 195阅读 0赞

### [一个对象占用多少字节？][Link 1] ###

*  http://yueyemaitian.iteye.com/blog/2033046

老早之前写过一篇博客，是关于一个Integer对象到底占用多少字节的，现在看来，那篇文章竟然计算错了。这次再去计算，是因为之前写的一篇[关于字长][Link 2]的文章里，看到了hotspot jvm里，对象占用空间是[8字节对齐][8]的，再加上之前关于字节那文章里带着一点-XX:+UseCompressedOops压缩指针参数的疑问，重新探究了下一个对象到底占用多少字节，以及如何计算它占用空间的方法。主要是参考了[这篇很久以前的文章][Link 3]，不过试验了一把，instrumentation这种方法还是靠谱的。

Java代码   ![收藏代码][icon_star.png]

1.  **import** java.lang.instrument.Instrumentation;  
2.  **import** java.lang.reflect.Array;  
3.  **import** java.lang.reflect.Field;  
4.  **import** java.lang.reflect.Modifier;  
5.  **import** java.util.ArrayDeque;  
6.  **import** java.util.Deque;  
7.  **import** java.util.HashSet;  
8.  **import** java.util.Set;  
9.    
10. /\*\* 
11.  \* 对象占用字节大小工具类 
12.  \* 
13.  \* @author tianmai.fh 
14.  \* @date 2014-03-18 11:29 
15.  \*/  
16. **public** **class** SizeOfObject \{  
17.     **static** Instrumentation inst;  
18.   
19.     **public** **static** **void** premain(String args, Instrumentation instP) \{  
20.         inst = instP;  
21.     \}  
22.   
23.     /\*\* 
24.      \* 直接计算当前对象占用空间大小，包括当前类及超类的基本类型实例字段大小、<br></br> 
25.      \* 引用类型实例字段引用大小、实例基本类型数组总占用空间、实例引用类型数组引用本身占用空间大小;<br></br> 
26.      \* 但是不包括超类继承下来的和当前类声明的实例引用字段的对象本身的大小、实例引用数组引用的对象本身的大小 <br></br> 
27.      \* 
28.      \* @param obj 
29.      \* @return 
30.      \*/  
31.     **public** **static** **long** sizeOf(Object obj) \{  
32.         **return** inst.getObjectSize(obj);  
33.     \}  
34.   
35.     /\*\* 
36.      \* 递归计算当前对象占用空间总大小，包括当前类和超类的实例字段大小以及实例字段引用对象大小 
37.      \* 
38.      \* @param objP 
39.      \* @return 
40.      \* @throws IllegalAccessException 
41.      \*/  
42.     **public** **static** **long** fullSizeOf(Object objP) **throws** IllegalAccessException \{  
43.         Set<Object> visited = **new** HashSet<Object>();  
44.         Deque<Object> toBeQueue = **new** ArrayDeque<>();  
45.         toBeQueue.add(objP);  
46.         **long** size = 0L;  
47.         **while** (toBeQueue.size() > 0) \{  
48.             Object obj = toBeQueue.poll();  
49.             //sizeOf的时候已经计基本类型和引用的长度，包括数组  
50.             size += skipObject(visited, obj) ? 0L : sizeOf(obj);  
51.             Class<?> tmpObjClass = obj.getClass();  
52.             **if** (tmpObjClass.isArray()) \{  
53.                 //\[I , \[F 基本类型名字长度是2  
54.                 **if** (tmpObjClass.getName().length() > 2) \{  
55.                     **for** (**int** i = 0, len = Array.getLength(obj); i < len; i++) \{  
56.                         Object tmp = Array.get(obj, i);  
57.                         **if** (tmp != **null**) \{  
58.                             //非基本类型需要深度遍历其对象  
59.                             toBeQueue.add(Array.get(obj, i));  
60.                         \}  
61.                     \}  
62.                 \}  
63.             \} **else** \{  
64.                 **while** (tmpObjClass != **null**) \{  
65.                     Field\[\] fields = tmpObjClass.getDeclaredFields();  
66.                     **for** (Field field : fields) \{  
67.                         **if** (Modifier.isStatic(field.getModifiers())   //静态不计  
68.                                 || field.getType().isPrimitive()) \{    //基本类型不重复计  
69.                             **continue**;  
70.                         \}  
71.   
72.                         field.setAccessible(**true**);  
73.                         Object fieldValue = field.get(obj);  
74.                         **if** (fieldValue == **null**) \{  
75.                             **continue**;  
76.                         \}  
77.                         toBeQueue.add(fieldValue);  
78.                     \}  
79.                     tmpObjClass = tmpObjClass.getSuperclass();  
80.                 \}  
81.             \}  
82.         \}  
83.         **return** size;  
84.     \}  
85.   
86.     /\*\* 
87.      \* String.intern的对象不计；计算过的不计，也避免死循环 
88.      \* 
89.      \* @param visited 
90.      \* @param obj 
91.      \* @return 
92.      \*/  
93.     **static** **boolean** skipObject(Set<Object> visited, Object obj) \{  
94.         **if** (obj **instanceof** String && obj == ((String) obj).intern()) \{  
95.             **return** **true**;  
96.         \}  
97.         **return** visited.contains(obj);  
98.     \}  
99. \}

跑代码前，需要按照那篇很老的文章先打包，这样才能注入Instrumentation实例，打包时候需要在MANIFEST.MF中写入三项值（注意包路径名改成自己的包名）：

Java代码   ![收藏代码][icon_star.png]

1.  Premain-**class**: xxx.yyy.zzz.SizeOfObject  
2.  Can-Redefine-Classes: **false**  
3.  Boot-Class-Path:

来看看测试类：

Java代码   ![收藏代码][icon_star.png]

1.  **import** java.io.File;  
2.  **import** **static** com.tmall.buy.structure.SizeOfObject.\*;  
3.  /\*\* 
4.   \* @author tianmai.fh 
5.   \* @date 2014-03-18 20:17 
6.   \*/  
7.  **public** **class** SizeOfObjectTest \{  
8.      /\*\* 
9.       \* -XX:+UseCompressedOops: mark/4 + metedata/8 + 4 = 16 
10.      \* -XX:-UseCompressedOops: mark/8 + metedata/8 + 4 + padding/4 = 24 
11.      \*/  
12.     **static** **class** A \{  
13.         **int** a;  
14.     \}  
15.   
16.     /\*\* 
17.      \* -XX:+UseCompressedOops: mark/4 + metedata/8 + 4 + 4 + padding/4 = 24 
18.      \* -XX:-UseCompressedOops: mark/8 + metedata/8 + 4 + 4 = 24 
19.      \*/  
20.     **static** **class** B \{  
21.         **int** a;  
22.         **int** b;  
23.     \}  
24.   
25.     /\*\* 
26.      \* -XX:+UseCompressedOops: mark/4 + metedata/8 + 4 + 4 + padding/4 = 24 
27.      \* -XX:-UseCompressedOops: mark/8 + metedata/8 + 8 + 4 + padding/4 = 32 
28.      \*/  
29.     **static** **class** B2 \{  
30.         **int** b2a;  
31.         Integer b2b;  
32.     \}  
33.   
34.     /\*\* 
35.      \* 不考虑对象头： 
36.      \* 4 + 4 + 4 \* 3 + 3 \* sizeOf(B) 
37.      \*/  
38.     **static** **class** C **extends** A \{  
39.         **int** ba;  
40.         B\[\] as = **new** B\[3\];  
41.   
42.         C() \{  
43.             **for** (**int** i = 0; i < as.length; i++) \{  
44.                 as\[i\] = **new** B();  
45.             \}  
46.         \}  
47.     \}  
48.   
49.     **static** **class** D **extends** B \{  
50.         **int** da;  
51.         Integer\[\] di = **new** Integer\[3\];  
52.     \}  
53.   
54.     /\*\* 
55.      \* 会算上A的实例字段 
56.      \*/  
57.     **static** **class** E **extends** A \{  
58.         **int** ea;  
59.         **int** eb;  
60.     \}  
61.   
62.     **public** **static** **void** main(String\[\] args) **throws** IllegalAccessException \{  
63.         System.out.println(**new** File("./target/classes").getAbsolutePath());  
64.         System.out.println("sizeOf(new Object())=" + sizeOf(**new** Object()));  
65.         System.out.println("sizeOf(new A())=" + sizeOf(**new** A()));  
66.         System.out.println("sizeOf(new B())=" + sizeOf(**new** B()));  
67.         System.out.println("sizeOf(new B2())=" + sizeOf(**new** B2()));  
68.         System.out.println("sizeOf(new B\[3\])=" + sizeOf(**new** B\[3\]));  
69.         System.out.println("sizeOf(new C())=" + sizeOf(**new** C()));  
70.         System.out.println("fullSizeOf(new C())=" + fullSizeOf(**new** C()));  
71.         System.out.println("sizeOf(new D())=" + sizeOf(**new** D()));  
72.         System.out.println("fullSizeOf(new D())=" + fullSizeOf(**new** D()));  
73.         System.out.println("sizeOf(new int\[3\])=" + sizeOf(**new** **int**\[3\]));  
74.         System.out.println("sizeOf(new Integer(1)=" + sizeOf(**new** Integer(1)));  
75.         System.out.println("sizeOf(new Integer\[0\])=" + sizeOf(**new** Integer\[0\]));  
76.         System.out.println("sizeOf(new Integer\[1\])=" + sizeOf(**new** Integer\[1\]));  
77.         System.out.println("sizeOf(new Integer\[2\])=" + sizeOf(**new** Integer\[2\]));  
78.         System.out.println("sizeOf(new Integer\[3\])=" + sizeOf(**new** Integer\[3\]));  
79.         System.out.println("sizeOf(new Integer\[4\])=" + sizeOf(**new** Integer\[4\]));  
80.         System.out.println("sizeOf(new A\[3\])=" + sizeOf(**new** A\[3\]));  
81.         System.out.println("sizeOf(new E())=" + sizeOf(**new** E()));  
82.     \}  
83. \}

如果你是用maven打包的话，可以考虑[在pom.xml文件中配置][pom.xml]。打完jar包后，可以直接运行SizeOfObject了，但是要加上vm启动参数（test.jar是刚才打的jar包）：

Java代码   ![收藏代码][icon_star.png]

1.  \-javaagent:target/test.jar

在我64bit mac上，跑64位hotspot vm的结果如下，其中压缩对象指针参数是开启的，即-XX:+UseCompressedOops

Java代码   ![收藏代码][icon_star.png]

1.  sizeOf(**new** Object())=16  
2.  sizeOf(**new** A())=16  
3.  sizeOf(**new** B())=24  
4.  sizeOf(**new** B2())=24  
5.  sizeOf(**new** B\[3\])=32  
6.  sizeOf(**new** C())=24  
7.  fullSizeOf(**new** C())=128  
8.  sizeOf(**new** D())=32  
9.  fullSizeOf(**new** D())=64  
10. sizeOf(**new** **int**\[3\])=32  
11. sizeOf(**new** Integer(1)=16  
12. sizeOf(**new** Integer\[0\])=16  
13. sizeOf(**new** Integer\[1\])=24  
14. sizeOf(**new** Integer\[2\])=24  
15. sizeOf(**new** Integer\[3\])=32  
16. sizeOf(**new** Integer\[4\])=32  
17. sizeOf(**new** A\[3\])=32  
18. sizeOf(**new** E())=24

如果关闭指针压缩，即在vm启动参数中加上-XX:-UseCompressedOops结果会不一样：

Java代码   ![收藏代码][icon_star.png]

1.  sizeOf(**new** Object())=16  
2.  sizeOf(**new** A())=24  
3.  sizeOf(**new** B())=24  
4.  sizeOf(**new** B2())=32  
5.  sizeOf(**new** B\[3\])=48  
6.  sizeOf(**new** C())=40  
7.  fullSizeOf(**new** C())=160  
8.  sizeOf(**new** D())=40  
9.  fullSizeOf(**new** D())=88  
10. sizeOf(**new** **int**\[3\])=40  
11. sizeOf(**new** Integer(1)=24  
12. sizeOf(**new** Integer\[0\])=24  
13. sizeOf(**new** Integer\[1\])=32  
14. sizeOf(**new** Integer\[2\])=40  
15. sizeOf(**new** Integer\[3\])=48  
16. sizeOf(**new** Integer\[4\])=56  
17. sizeOf(**new** A\[3\])=48  
18. sizeOf(**new** E())=32

UseCompressOops开启和关闭，对对象头大小是有影响的，开启压缩，对象头是4+8=12byte；关闭压缩，对象头是8+8=16bytes。这个如何观察验证呢？

基于上述事实，通过new A()和new B()占用字节推断，基本类型int在开启、关闭压缩情况下都是占用4个bytes的，这个没有影响。而通过B和B2在开启、关闭指针压缩情况下的对比看，Integer类型分别占了4 bytes和8 bytes，实际上引用类型都是这样。如何验证？

new Integer\[0\]在压缩前后分别占用16、24个字节，这是又是为什么呢？

欲知后事，[且听下回分解][Link 4]！enjoy it !

[Link 1]: http://yueyemaitian.iteye.com/blog/2033046
[Link 2]: http://yueyemaitian.iteye.com/blog/2031644
[8]: http://hllvm.group.iteye.com/group/topic/38068
[Link 3]: http://www.jroller.com/maxim/entry/again_about_determining_size_of
[icon_star.png]: /images/20220614/4c15261b33404c54a52a0c09168d7f1a.png
[pom.xml]: http://yueyemaitian.iteye.com/blog/2032856
[Link 4]: http://yueyemaitian.iteye.com/blog/2034305

发表评论取消回复

表情：

评论列表（有 0 条评论，195人围观）

还没有评论，来说两句吧...

相关阅读

相关 Java中的char类型占用多少字节？

Java中的char类型是用来表示Unicode字符的数据类型，它占用2个字节（16位）的存储空间。每个char值可以表示范围在0到65535之间的一个字符。下面是一个简单

墨蓝/ 2024年02月29日 01:06/ 0 赞/ 23 阅读

相关一个对象最小占用内存多少?

1. 我们首先引用一个jar包，JOL全称为Java Object Layout，是分析JVM中对象布局的工具。 <dependency>

你的名字/ 2023年02月11日 14:29/ 0 赞/ 52 阅读

相关一个Object对象要占用多少空间

java对象创建后，它的的组成部分如下： 1.对象头在jvm虚拟机中每一个java对象都有一个对象头，对象头中包含标记字段以

灰太狼/ 2022年12月25日 02:57/ 0 赞/ 110 阅读

相关【转】Java new一个Object对象占用多少内存？

Java的自动内存管理机制（[automatic storage management system known as a garbage collector][]）省却了很多

心已赠人/ 2022年12月20日 11:11/ 0 赞/ 131 阅读

相关 java中一个对象占多少字节

组成对象头+实例+填充。一个空java对象在64位下占16字节（压缩后12字节），对象头占两个字节，MarkWord 存储对象的hashcode值，锁的信息，gc

本是古典何须时尚/ 2022年11月22日 00:00/ 0 赞/ 103 阅读

相关 Java中boolean类型占用多少个字节

> 今天突然想到这个问题，百度了下，找到个解释比较好的，转载来，大家一起看看。仅供学习，侵权联系删除！ Java中boolean类型占用多少个字节为什么要问这个问题，

电玩女神/ 2022年09月02日 03:52/ 0 赞/ 160 阅读

相关一个对象占用多少字节？

[一个对象占用多少字节？][Link 1] http://yueyemaitian.iteye.com/blog/2033046 老

谁践踏了优雅/ 2022年06月14日 03:18/ 0 赞/ 196 阅读

相关 Java中boolean类型占用多少个字节

为什么要问这个问题，首先在Java中定义的八种基本数据类型中，除了其它七种类型都有明确的内存占用字节数外，就boolean类型没有给出具体的占用字节数，因为对虚拟机来说根本就不

悠悠/ 2022年06月08日 14:54/ 0 赞/ 163 阅读

相关 C++中一个class类对象占用多少内字节

一个空的class在内存中多少字节？如果加入一个成员函数后是多大？这个成员函数存储在内存中什么部分？一个Class对象需要占用多大的内存空间。最权威的结论是： `非静态

分手后的思念是犯贱/ 2022年05月28日 01:13/ 0 赞/ 134 阅读

相关面试题:一个HashMap对象占多少字节

![640?wx\_fmt=gif][640_wx_fmt_gif] 对象=对象头+成员变量+对齐填充对象头结构：java对象在Heap里面的结构是这样的：对象头跟对象体

你的名字/ 2022年01月23日 03:19/ 0 赞/ 394 阅读