查看java对象占用多少字节的代码小工具

本文转载自查看原文 2018-03-21 17:28 1013 copy代码小工具/ code工具

原文：http://yueyemaitian.iteye.com/blog/2033046

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

Java代码

 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 }

View Code

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

Java代码：

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

来看看测试类：

 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 }

View Code

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

Java代码

1 -javaagent:target/test.jar

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

 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

View Code

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

 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

View Code

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

欲知后事，且听下回分解！enjoy it !

免责声明！

本站转载的文章为个人学习借鉴使用，本站对版权不负任何法律责任。如果侵犯了您的隐私权益，请联系本站邮箱yoyou2525@163.com删除。

猜您在找 SQL转Java代码小工具小工具:内存占用工具小工具系列之json查看小工具 Python小工具-查看内存和CPU java 编写小工具尝试学习（一） java 几个实用的小工具基于Java 的增量与完全备份小工具 Java11 & JavaFX 初体验 - Java 代码生成 Markdown 的小工具生物小工具小工具