查看java对象在内存中的布局
接着上篇《一个对象占用多少字节?》中遇到的问题:
基于上述事实,通过new A()和new B()占用字节推断,基本类型int在开启、关闭压缩情况下都是占用4个bytes的,这个没有影响。而通过B和B2在开启、关闭指针压缩情况下的对比看,Integer类型分别占了4 bytes和8 bytes,实际上引用类型都是这样。如何验证?
new Integer[0]在压缩前后分别占用16、24个字节,这是又是为什么呢?
其实要想验证这些信息,需要知道对象在内存中的布局,并且可以把他们输出出来,很巧看到了撒加(RednaxelaFX)大神的《借助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位。
import sun.misc.Unsafe;
import java.lang.reflect.Field;
/**
* -Xmx1024m
* @author tianmai.fh
* @date 2014-03-18 19:10
*/
public class FieldOffsetTest {
static Unsafe unsafe;
static {
Field field = null;
try {
field = Unsafe.class.getDeclaredField("theUnsafe");
field.setAccessible(true);
unsafe = (Unsafe) field.get(null);
} catch (NoSuchFieldException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
static class MyClass {
Object a = new Object();
Integer b = new Integer(3);
int c = 4;
long d = 5L;
Long[] e = new Long[2];
Object[] f = new String[0];
}
static class B2 {
int a;
Integer b;
int c;
}
static long objectFieldOffset(Field field) {
return unsafe.objectFieldOffset(field);
}
static String objectFieldOffset(Class<?> clazz) {
Field[] fields = clazz.getDeclaredFields();
StringBuilder sb = new StringBuilder(fields.length * 50);
sb.append(clazz.getName()).append(" Field offset:\n");
for (Field field : fields) {
sb.append("\t").append(field.getType().getSimpleName());
sb.append("\t").append(field.getName()).append(": ");
sb.append(objectFieldOffset(field)).append("\n");
}
return sb.toString();
}
public static void main(String[] args) throws InterruptedException, NoSuchFieldException {
MyClass mc = new MyClass();
int[] big = new int[30 * 1024 * 1024];
big = null;
System.gc();
System.out.println(objectFieldOffset((MyClass.class)));
System.out.println(objectFieldOffset((B2.class)));
Object a = new Long[1];
System.out.println(Long[].class.getName());
Thread.sleep(1000000);
}
}
在启用指针压缩的情况下输出为:
com.tmall.buy.structure.FieldOffsetTest$MyClass Field offset:
Object a: 24
Integer b: 28
int c: 12
long d: 16
Long[] e: 32
Object[]f: 36
com.tmall.buy.structure.FieldOffsetTest$B2 Field offset:
int a: 12
Integer b: 20
int c: 16
第一个实例变量的偏移量都是12,也就是说对象头占用了12个字节;基本类型int占用4个字节;对象引用占用了4个字节,如MyClass#a;对象数组占用也是4个字节;这里看不出数组这个对象占用了多少个字节。
在不启用对象指针压缩的时候(vm参数添加-XX:-UseCompressedOops):
com.tmall.buy.structure.FieldOffsetTest$MyClass Field offset:
Object a: 32
Integer b: 40
int c: 24
long d: 16
Long[] e: 48
Object[] f: 56
com.tmall.buy.structure.FieldOffsetTest$B2 Field offset:
int a: 16
Integer b: 24
int c: 20
第一个实例变量的偏移量都是16,也就是说对象头占用了16个字节;基本类型int占用4个字节;对象引用占用了8个字节,如MyClass#a;对象数组占用也是8个字节;这里看不出数组这个对象占用了多少个字节。
那接下来通过对象的内存布局进一步验证:
import sun.jvm.hotspot.oops.*;
import sun.jvm.hotspot.runtime.VM;
import sun.jvm.hotspot.tools.Tool;
import sun.jvm.hotspot.utilities.SystemDictionaryHelper;
/**
* 打印对象的内存布局
*/
public class PrintObjectTest extends Tool {
public static void main(String[] args) throws InterruptedException {
PrintObjectTest test = new PrintObjectTest();
test.start(args);
test.stop();
}
@Override
public void run() {
VM vm = VM.getVM();
ObjectHeap objHeap = vm.getObjectHeap();
HeapVisitor heapVisitor = new HeapPrinter(System.out);
//观察特定对象
Klass klass = SystemDictionaryHelper.findInstanceKlass("xxx.yyy.zzz.FieldOffsetTest$MyClass");
objHeap.iterateObjectsOfKlass(heapVisitor, klass, false);
//观察数组对象
objHeap.iterate(heapVisitor,new ObjectHeap.ObjectFilter() {
@Override
public boolean canInclude(Oop oop) {
return oop.isObjArray();
}
});
objHeap.iterate(heapVisitor);
}
}
这个程序在运行前,需要传入要监控的java进程id,也就是上边那个程序的进程id,可以通过jps拿到。但是在我的IDEA上,是跑不起来的,是由于权限问题:
Attaching to process ID 1923, please wait...
attach: task_for_pid(1923) failed (5)
Error attaching to process: sun.jvm.hotspot.debugger.DebuggerException: Can't attach to the process
用命令行,sudo就可以了:
sudo java -cp $JAVA_HOME/lib/sa-jdi.jar:. xxx.yyy.zzz.PrintObjectTest 进程id > heap_OOps.txt
如果你被监控的jvm实例是1.7.x启动的,而命令行监控实例通过1.8的jdk启动,会抛出如下错误:
Attaching to process ID 3024, please wait...
Exception in thread "main" java.lang.NoSuchMethodError: getJavaThreadsInfo
at sun.jvm.hotspot.debugger.bsd.BsdDebuggerLocal.init0(Native Method)
at sun.jvm.hotspot.debugger.bsd.BsdDebuggerLocal.<clinit>(BsdDebuggerLocal.java:595)
at sun.jvm.hotspot.bugspot.BugSpotAgent.setupDebuggerBsd(BugSpotAgent.java:775)
at sun.jvm.hotspot.bugspot.BugSpotAgent.setupDebugger(BugSpotAgent.java:519)
at sun.jvm.hotspot.bugspot.BugSpotAgent.go(BugSpotAgent.java:492)
at sun.jvm.hotspot.bugspot.BugSpotAgent.attach(BugSpotAgent.java:331)
at sun.jvm.hotspot.tools.Tool.start(Tool.java:163)
at com.tmall.buy.structure.PrintObjectTest.main(PrintObjectTest.java:14)
直接全路径用1.7的jdk带的java启动就好了。
接下来我们看输出,这个是启用指针压缩的,由于输出比较长,我们就只关心我们想看的几个:
Oop for com/tmall/buy/structure/FieldOffsetTest$MyClass @ 0x000000011bfce258 (object size = 40)
- _mark: {0} :1
- _metadata._compressed_klass: {8} :InstanceKlass for com/tmall/buy/structure/FieldOffsetTest$MyClass @ 0x0000000146d2a160
- a: {24} :Oop for java/lang/Object @ 0x000000011bf9bb90
- b: {28} :Oop for java/lang/Integer @ 0x000000011bf9bba8
- c: {12} :4
- d: {16} :5
- e: {32} :ObjArray @ 0x000000011bf9bbc0
- f: {36} :ObjArray @ 0x000000011bf9bbd8
...
ObjArray @ 0x000000011bf9bbc0 (object size = 24)
- _mark: {0} :1
- _metadata._compressed_klass: {8} :ObjArrayKlass for InstanceKlass for java/lang/Long @ 0x0000000146d2b910
- 0: {16} :null
- 1: {20} :null
...
ObjArray @ 0x000000011bf9bbd8 (object size = 16)
- _mark: {0} :1
- _metadata._compressed_klass: {8} :ObjArrayKlass for InstanceKlass for java/lang/String @ 0x0000000146b229c0
...
可以看到,MyClass这个类的大小是40个字节,不包括它引用的对象的大小,其中大括号是对象实例字段的偏移量,单位是字节。验证了对象头是12 bytes,其中_mark占8个字节_metadata._compressed_klass占用4个字节;剩下的就跟第一个例子中启用了压缩指针的结论一致。这里我们也可以看到数据对象占用的内存空间了,数组对象的头部占用了16个字节,_mark占8个,_metadata._compressed_klass占8个;另外也验证了,对象是8字节对齐的。
在看不启用对象指针压缩的情况:
Oop for com/tmall/buy/structure/FieldOffsetTest$MyClass @ 0x000000011ad491e8 (object size = 64)
- _mark: {0} :1
- _metadata._klass: {8} :InstanceKlass for com/tmall/buy/structure/FieldOffsetTest$MyClass @ 0x0000000145a873d8
- a: {32} :Oop for java/lang/Object @ 0x000000011ad1e1a8
- b: {40} :Oop for java/lang/Integer @ 0x000000011ad211b8
- c: {24} :4
- d: {16} :5
- e: {48} :ObjArray @ 0x000000011ad201c8
- f: {56} :ObjArray @ 0x000000011ad211d0
...
ObjArray @ 0x000000011ad201c8 (object size = 40)
- _mark: {0} :1
- _metadata._klass: {8} :ObjArrayKlass for InstanceKlass for java/lang/Long @ 0x0000000145a88120
- 0: {24} :null
- 1: {32} :null
...
ObjArray @ 0x000000011ad211d0 (object size = 24)
- _mark: {0} :1
- _metadata._klass: {8} :ObjArrayKlass for InstanceKlass for java/lang/String @ 0x0000000145876ef0
...
MyClass这个类的大小是64个字节,不包括它引用的对象的大小,其中大括号是对象实例字段的偏移量,单位是字节。验证了对象头是16 bytes,其中_mark占8个字节_metadata._klass占用8个字节;剩下的就跟第一个例子中不启用了压缩指针的结论一致。数组对象的头部占用了24个字节,_mark占8个,_metadata._compressed_klass占16个;另外也验证了,对象是8字节对齐的。
tips:在查找MyClass对象中数组类型实例字段的内存布局时,可以直接用后边的内存地址搜索@ 0x000000011ad201c8。
关于对象更多描述信息,请移步到开篇引用的RednaxelaFX那篇文章中学习。enjoy it!
上一篇: Helm快速入门指南
下一篇: 在kubernetes中运行的容器