查看Java对象在内存中的布局

柔情只为你懂 2022-06-14 03:18 305阅读 0赞

[查看java对象在内存中的布局][java]

http://yueyemaitian.iteye.com/blog/2034305

接着上篇[《一个对象占用多少字节？》][Link 1]中遇到的问题：

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个字节，这是又是为什么呢？

其实要想验证这些信息，需要知道对象在内存中的布局，并且可以把他们输出出来，很巧看到了撒加（RednaxelaFX）大神的[《借助HotSpot SA来一窥PermGen上的对象》][HotSpot SA_PermGen]，可以一窥java对象在内存中的布局。不过我没搞那么复杂，没用oom的方式输出内存对象信息——主要是由于在我的mac os x上Intellij IDEA权限的原因那样做不成功——而是通过启动两个进程的方式，一个监控程序和一个被监控程序。

先写了个程序，也用unsafe的方法获取到字段偏移量，来跟通过SA的方式做对比。首先说明，我的os是Mac OSX 10.9.2，64bit机器，jdk是jdk1.7.0\_11，64位。

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

1.  **import** sun.misc.Unsafe;  
2.    
3.  **import** java.lang.reflect.Field;  
4.    
5.  /\*\* 
6.   \* -Xmx1024m 
7.   \* @author tianmai.fh 
8.   \* @date 2014-03-18 19:10 
9.   \*/  
10. **public** **class** FieldOffsetTest \{  
11.     **static** Unsafe unsafe;  
12.   
13.     **static** \{  
14.         Field field = **null**;  
15.         **try** \{  
16.             field = Unsafe.**class**.getDeclaredField("theUnsafe");  
17.             field.setAccessible(**true**);  
18.             unsafe = (Unsafe) field.get(**null**);  
19.         \} **catch** (NoSuchFieldException e) \{  
20.             e.printStackTrace();  
21.         \} **catch** (IllegalAccessException e) \{  
22.             e.printStackTrace();  
23.         \}  
24.     \}  
25.   
26.     **static** **class** MyClass \{  
27.         Object a = **new** Object();  
28.         Integer b = **new** Integer(3);  
29.         **int** c = 4;  
30.         **long** d = 5L;  
31.         Long\[\] e = **new** Long\[2\];  
32.         Object\[\] f = **new** String\[0\];  
33.     \}  
34.     **static** **class** B2 \{  
35.         **int** a;  
36.         Integer b;  
37.         **int** c;  
38.     \}  
39.   
40.     **static** **long** objectFieldOffset(Field field) \{  
41.         **return** unsafe.objectFieldOffset(field);  
42.     \}  
43.   
44.     **static** String objectFieldOffset(Class<?> clazz) \{  
45.         Field\[\] fields = clazz.getDeclaredFields();  
46.         StringBuilder sb = **new** StringBuilder(fields.length \* 50);  
47.         sb.append(clazz.getName()).append(" Field offset:\\n");  
48.         **for** (Field field : fields) \{  
49.             sb.append("\\t").append(field.getType().getSimpleName());  
50.             sb.append("\\t").append(field.getName()).append(": ");  
51.             sb.append(objectFieldOffset(field)).append("\\n");  
52.         \}  
53.         **return** sb.toString();  
54.     \}  
55.   
56.     **public** **static** **void** main(String\[\] args) **throws** InterruptedException, NoSuchFieldException \{  
57.         MyClass mc = **new** MyClass();  
58.         **int**\[\] big = **new** **int**\[30 \* 1024 \* 1024\];  
59.         big = **null**;  
60.         System.gc();  
61.         System.out.println(objectFieldOffset((MyClass.**class**)));  
62.         System.out.println(objectFieldOffset((B2.**class**)));  
63.         Object a = **new** Long\[1\];  
64.         System.out.println(Long\[\].**class**.getName());  
65.         Thread.sleep(1000000);  
66.     \}  
67. \}

在启用指针压缩的情况下输出为：

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

1.  com.tmall.buy.structure.FieldOffsetTest$MyClass Field offset:  
2.      Object  a: 24  
3.      Integer b: 28  
4.      **int** c: 12  
5.      **long**    d: 16  
6.      Long\[\]  e: 32  
7.      Object\[\]f: 36  
8.    
9.  com.tmall.buy.structure.FieldOffsetTest$B2 Field offset:  
10.     **int** a: 12  
11.     Integer b: 20  
12.     **int** c: 16

第一个实例变量的偏移量都是12，也就是说对象头占用了12个字节；基本类型int占用4个字节；对象引用占用了4个字节，如MyClass\#a；对象数组占用也是4个字节；这里看不出数组这个对象占用了多少个字节。

在不启用对象指针压缩的时候（vm参数添加-XX:-UseCompressedOops）：

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

1.  com.tmall.buy.structure.FieldOffsetTest$MyClass Field offset:  
2.      Object  a: 32  
3.      Integer b: 40  
4.      **int** c: 24  
5.      **long**    d: 16  
6.      Long\[\]  e: 48  
7.      Object\[\]    f: 56  
8.    
9.  com.tmall.buy.structure.FieldOffsetTest$B2 Field offset:  
10.     **int** a: 16  
11.     Integer b: 24  
12.     **int** c: 20

第一个实例变量的偏移量都是16，也就是说对象头占用了16个字节；基本类型int占用4个字节；对象引用占用了8个字节，如MyClass\#a；对象数组占用也是8个字节；这里看不出数组这个对象占用了多少个字节。

那接下来通过对象的内存布局进一步验证：

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

1.  **import** sun.jvm.hotspot.oops.\*;  
2.  **import** sun.jvm.hotspot.runtime.VM;  
3.  **import** sun.jvm.hotspot.tools.Tool;  
4.  **import** sun.jvm.hotspot.utilities.SystemDictionaryHelper;  
5.    
6.  /\*\* 
7.   \* 打印对象的内存布局 
8.   \*/  
9.  **public** **class** PrintObjectTest **extends** Tool \{  
10.     **public** **static** **void** main(String\[\] args) **throws** InterruptedException \{  
11.         PrintObjectTest test = **new** PrintObjectTest();  
12.         test.start(args);  
13.         test.stop();  
14.     \}  
15.   
16.     @Override  
17.     **public** **void** run() \{  
18.         VM vm = VM.getVM();  
19.         ObjectHeap objHeap = vm.getObjectHeap();  
20.         HeapVisitor heapVisitor = **new** HeapPrinter(System.out);  
21.         //观察特定对象  
22.         Klass klass = SystemDictionaryHelper.findInstanceKlass("xxx.yyy.zzz.FieldOffsetTest$MyClass");  
23.         objHeap.iterateObjectsOfKlass(heapVisitor, klass, **false**);  
24.   
25.         //观察数组对象  
26.         objHeap.iterate(heapVisitor,**new** ObjectHeap.ObjectFilter() \{  
27.             @Override  
28.             **public** **boolean** canInclude(Oop oop) \{  
29.                 **return** oop.isObjArray();  
30.             \}  
31.         \});  
32.         objHeap.iterate(heapVisitor);  
33.     \}  
34. \}

这个程序在运行前，需要传入要监控的java进程id，也就是上边那个程序的进程id，可以通过jps拿到。但是在我的IDEA上，是跑不起来的，是由于权限问题：

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

1.  Attaching to process ID 1923, please wait...  
2.  attach: task\_for\_pid(1923) failed (5)  
3.  Error attaching to process: sun.jvm.hotspot.debugger.DebuggerException: Can't attach to the process

用命令行，sudo就可以了：

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

1.  sudo java -cp $JAVA\_HOME/lib/sa-jdi.jar:. xxx.yyy.zzz.PrintObjectTest 进程id > heap\_OOps.txt

如果你被监控的jvm实例是1.7.x启动的，而命令行监控实例通过1.8的jdk启动，会抛出如下错误：

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

1.  Attaching to process ID 3024, please wait...  
2.  Exception in thread "main" java.lang.NoSuchMethodError: getJavaThreadsInfo  
3.      at sun.jvm.hotspot.debugger.bsd.BsdDebuggerLocal.init0(Native Method)  
4.      at sun.jvm.hotspot.debugger.bsd.BsdDebuggerLocal.<clinit>(BsdDebuggerLocal.java:595)  
5.      at sun.jvm.hotspot.bugspot.BugSpotAgent.setupDebuggerBsd(BugSpotAgent.java:775)  
6.      at sun.jvm.hotspot.bugspot.BugSpotAgent.setupDebugger(BugSpotAgent.java:519)  
7.      at sun.jvm.hotspot.bugspot.BugSpotAgent.go(BugSpotAgent.java:492)  
8.      at sun.jvm.hotspot.bugspot.BugSpotAgent.attach(BugSpotAgent.java:331)  
9.      at sun.jvm.hotspot.tools.Tool.start(Tool.java:163)  
10.     at com.tmall.buy.structure.PrintObjectTest.main(PrintObjectTest.java:14)

直接全路径用1.7的jdk带的java启动就好了。

接下来我们看输出，这个是启用指针压缩的，由于输出比较长，我们就只关心我们想看的几个：

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

1.  Oop **for** com/tmall/buy/structure/FieldOffsetTest$MyClass @ 0x000000011bfce258 (object size = 40)  
2.   - \_mark:    \{ 0\} :1  
3.   - \_metadata.\_compressed\_klass:  \{ 8\} :InstanceKlass **for** com/tmall/buy/structure/FieldOffsetTest$MyClass @ 0x0000000146d2a160  
4.   - a:    \{ 24\} :Oop **for** java/lang/Object @ 0x000000011bf9bb90  
5.   - b:    \{ 28\} :Oop **for** java/lang/Integer @ 0x000000011bf9bba8  
6.   - c:    \{ 12\} :4  
7.   - d:    \{ 16\} :5  
8.   - e:    \{ 32\} :ObjArray @ 0x000000011bf9bbc0  
9.   - f:    \{ 36\} :ObjArray @ 0x000000011bf9bbd8  
10.   
11. ...  
12.   
13. ObjArray @ 0x000000011bf9bbc0 (object size = 24)  
14.  - \_mark:    \{ 0\} :1  
15.  - \_metadata.\_compressed\_klass:  \{ 8\} :ObjArrayKlass **for** InstanceKlass **for** java/lang/Long @ 0x0000000146d2b910  
16.  - 0:    \{ 16\} :**null**  
17.  - 1:    \{ 20\} :**null**  
18.   
19. ...  
20.   
21. ObjArray @ 0x000000011bf9bbd8 (object size = 16)  
22.  - \_mark:    \{ 0\} :1  
23.  - \_metadata.\_compressed\_klass:  \{ 8\} :ObjArrayKlass **for** InstanceKlass **for** java/lang/String @ 0x0000000146b229c0  
24.   
25. ...

可以看到，MyClass这个类的大小是40个字节，不包括它引用的对象的大小，其中大括号是对象实例字段的偏移量，单位是字节。验证了对象头是12 bytes，其中\_mark占8个字节\_metadata.\_compressed\_klass占用4个字节；剩下的就跟第一个例子中启用了压缩指针的结论一致。这里我们也可以看到数据对象占用的内存空间了，数组对象的头部占用了16个字节，\_mark占8个，\_metadata.\_compressed\_klass占8个；另外也验证了，对象是8字节对齐的。

在看不启用对象指针压缩的情况：

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

1.  Oop **for** com/tmall/buy/structure/FieldOffsetTest$MyClass @ 0x000000011ad491e8 (object size = 64)  
2.   - \_mark:    \{ 0\} :1  
3.   - \_metadata.\_klass:     \{ 8\} :InstanceKlass **for** com/tmall/buy/structure/FieldOffsetTest$MyClass @ 0x0000000145a873d8  
4.   - a:    \{ 32\} :Oop **for** java/lang/Object @ 0x000000011ad1e1a8  
5.   - b:    \{ 40\} :Oop **for** java/lang/Integer @ 0x000000011ad211b8  
6.   - c:    \{ 24\} :4  
7.   - d:    \{ 16\} :5  
8.   - e:    \{ 48\} :ObjArray @ 0x000000011ad201c8  
9.   - f:    \{ 56\} :ObjArray @ 0x000000011ad211d0  
10.   
11. ...  
12.   
13. ObjArray @ 0x000000011ad201c8 (object size = 40)  
14.  - \_mark:    \{ 0\} :1  
15.  - \_metadata.\_klass:     \{ 8\} :ObjArrayKlass **for** InstanceKlass **for** java/lang/Long @ 0x0000000145a88120  
16.  - 0:    \{ 24\} :**null**  
17.  - 1:    \{ 32\} :**null**  
18.   
19. ...  
20.   
21. ObjArray @ 0x000000011ad211d0 (object size = 24)  
22.  - \_mark:    \{ 0\} :1  
23.  - \_metadata.\_klass:     \{ 8\} :ObjArrayKlass **for** InstanceKlass **for** java/lang/String @ 0x0000000145876ef0  
24.   
25. ...

MyClass这个类的大小是64个字节，不包括它引用的对象的大小，其中大括号是对象实例字段的偏移量，单位是字节。验证了对象头是16 bytes，其中\_mark占8个字节\_metadata.\_klass占用8个字节；剩下的就跟第一个例子中不启用了压缩指针的结论一致。数组对象的头部占用了24个字节，\_mark占8个，\_metadata.\_compressed\_klass占16个；另外也验证了，对象是8字节对齐的。

tips：在查找MyClass对象中数组类型实例字段的内存布局时，可以直接用后边的内存地址搜索@ 0x000000011ad201c8。

关于对象更多描述信息，请移步到开篇引用的RednaxelaFX那篇文章中学习。enjoy it！

[java]: http://yueyemaitian.iteye.com/blog/2034305
[Link 1]: http://yueyemaitian.iteye.com/blog/2033046
[HotSpot SA_PermGen]: http://rednaxelafx.iteye.com/blog/730461
[icon_star.png]: /images/20220614/b3212c56a21f48b28dd6f39855e71f42.png

发表评论取消回复

表情：

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

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

相关阅读

相关 jvm-对象的内存布局&对象在内存中的布局 - 面试宝典

![cbf6c2b0ce5a93f38db56edfa91471cd.png][] JVM（Java虚拟机）是Java程序运行的平台，它负责将Java源代码编译成字节码并执行

野性酷女/ 2024年03月24日 22:35/ 0 赞/ 71 阅读

相关 jvm - 对象在内存中的布局

JVM中的对象在内存中的布局主要包括对象头、实例数据和对齐填充三个部分。 1. 对象头：对象头包括两部分内容： Mark Word（标记字段）：用于存储对象的运行时

谁借莪１个温暖的怀抱￠/ 2024年03月22日 23:56/ 0 赞/ 74 阅读

相关 jvm-对象的内存布局&对象在内存中的布局

JVM（Java虚拟机）是Java程序运行的平台，它负责将Java源代码编译成字节码并执行。在JVM中，对象在内存中的布局可以分为三个部分：对象头、实例数据和对齐填充。 1.

布满荆棘的人生/ 2024年03月22日 23:30/ 0 赞/ 74 阅读

相关 Java对象内存布局

一、Java对象内存布局 Java对象的内存布局：对象头（Header）、实例数据（Instance Data）和对齐填充（Padding）。无论是32

曾经终败给现在/ 2022年12月23日 06:52/ 0 赞/ 120 阅读

相关 Java对象内存布局

对象在堆内存中布局摘自周志明老师JVM第3版 ![image-20210902163833095][] ![image-20210908174741760][]

╰+哭是因爲堅強的太久メ/ 2022年09月12日 13:57/ 0 赞/ 237 阅读

相关 Java对象的内存布局

在HotSpot虚拟机中，对象在内存中存储的布局可以分为3块区域：对象头（Header）、实例数据（Instance Data）和对齐填充（Padding）。对象头

以你之姓@/ 2022年06月18日 05:22/ 0 赞/ 257 阅读

相关查看Java对象在内存中的布局

[查看java对象在内存中的布局][java] http://yueyemaitian.iteye.com/blog/2034305 接着上篇[《一个对象占用多少字

柔情只为你懂/ 2022年06月14日 03:18/ 0 赞/ 306 阅读

相关 JAVA 对象内存布局

Java对象的内存布局：对象头（Header）实例数据（Instance Data）对齐填充（Padding）虚拟机的对象头包括两部分信息第

墨蓝/ 2022年06月12日 04:37/ 0 赞/ 225 阅读

相关虚函数在对象中的内存布局

典型地，C++通过虚函数实现多态性。多态性的定义：“无论发送消息的对象属于什么类，他们均发送具有相同形式的消息，对消息的处理方式可能随接受消息的对象而变。”具体地说，“在某个基

￡神魔★判官ぃ/ 2022年02月20日 04:23/ 0 赞/ 224 阅读

相关 Java中对象的内存布局

Java中对象的内存布局在HotSpot虚拟机中。对象在内存中存储的布局分为 1.对象头 2.实例数据 3.对齐填充 1、对象头 ...

小灰灰/ 2020年11月06日 12:46/ 0 赞/ 766 阅读