Java对象大小计算

这篇说说如何计算Java对象大小的方法。之前在聊聊高并发（四）Java对象的表示模型和运行时内存表示 这篇中已经说了Java对象的内存表示模型是Oop-Klass模型。

普通对象的结构如下，按64位机器的长度计算

1. 对象头(_mark)， 8个字节

2. Oop指针，如果是32G内存以下的，默认开启对象指针压缩，4个字节

3. 数据区

4.Padding(内存对齐)，按照8的倍数对齐

数组对象结构是

1. 对象头(_mark)， 8个字节

2. Oop指针，如果是32G内存以下的，默认开启对象指针压缩，4个字节

3. 数组长度，4个字节

4. 数据区

5. Padding(内存对齐)，按照8的倍数对齐

清楚了对象在内存的基本布局后，咱们说两种计算Java对象大小的方法

1. 通过java.lang.instrument.Instrumentation的getObjectSize(obj)直接获取对象的大小

2. 通过sun.misc.Unsafe对象的objectFieldOffset(field)等方法结合反射来计算对象的大小

java.lang.instrument.Instrumentation.getObjectSize()的方式

先讲讲java.lang.instrument.Instrumentation.getObjectSize()的方式，这种方法得到的是Shallow Size，即遇到引用时，只计算引用的长度，不计算所引用的对象的实际大小。如果要计算所引用对象的实际大小，可以通过递归的方式去计算。

java.lang.instrument.Instrumentation的实例必须通过指定javaagent的方式才能获得，具体的步骤如下：

1. 定义一个类，提供一个premain方法: public static void premain(String agentArgs, Instrumentation instP)

2. 创建META-INF/MANIFEST.MF文件，内容是指定PreMain的类是哪个： Premain-Class: sizeof.ObjectShallowSize

3. 把这个类打成jar，然后用java -javaagent XXXX.jar XXX.main的方式执行

下面先定义一个类来获得java.lang.instrument.Instrumentation的实例,并提供了一个static的sizeOf方法对外提供Instrumentation的能力

1. package sizeof;
2. import java.lang.instrument.Instrumentation;
3. public class ObjectShallowSize {
4. private static Instrumentation inst;
5. public static void premain(String agentArgs, Instrumentation instP){
6. inst = instP;
7. }
8. public static long sizeOf(Object obj){
9. return inst.getObjectSize(obj);
10. }
11. }

定义META-INF/MANIFEST.MF文件

1. Premain-Class: sizeof.ObjectShallowSize

打成jar包

1. cd 编译后的类和META-INF文件夹所在目录
2. jar cvfm java-agent-sizeof.jar META-INF/MANIFEST.MF  .

准备好了这个jar之后，我们可以写测试类来测试Instrumentation的getObjectSize方法了。在这之前我们先来看对象在内存中是按照什么顺序排列的

有如下这个类，字段的定义按如下顺序

1. private static class ObjectA {
2. String str;  // 4
3. int i1; // 4
4. byte b1; // 1
5. byte b2; // 1
6. int i2;  // 4
7. ObjectB obj; //4
8. byte b3;  // 1
9. }

按照我们之前说的方法来计算一下这个对象所占大小，注意按8对齐

8(_mark) + 4(oop指针) + 4(str) + 4(i1) + 1(b1) + 1(b2) + 2(padding) + 4(i2) + 4(obj) + 1(b3) + 7(padding) = 40 ?

但事实上是这样的吗？ 我们来用Instrumentation的getObjectSize来计算一下先:

1. package test;
2. import sizeof.ObjectShallowSize;
3. public class SizeofWithInstrumetation {
4. private static class ObjectA {
5. String str;  // 4
6. int i1; // 4
7. byte b1; // 1
8. byte b2; // 1
9. int i2;  // 4
10. ObjectB obj; //4
11. byte b3;  // 1
12. }
13. private static class ObjectB {
14. }
15. public static void main(String[] args){
16. System.out.println(ObjectShallowSize.sizeOf(new ObjectA()));
17. }
18. }

得到的结果是32！不是会按8对齐吗，b3之前的数据加起来已经是32了，多了1个b3，为33，应该对齐到40才对啊。事实上，HotSpot创建的对象的字段会先按照给定顺序排列一下,默认的顺序如下，从长到短排列，引用排最后:  long/double --> int/float -->  short/char --> byte/boolean --> Reference

这个顺序可以使用JVM参数:  -XX:FieldsAllocationSylte=0(默认是1)来改变。

我们使用sun.misc.Unsafe对象的objectFieldOffset方法来验证一下:

1. Field[] fields = ObjectA.class.getDeclaredFields();
2. for(Field f: fields){
3. System.out.println(f.getName() + " offset: " +unsafe.objectFieldOffset(f));
4. }

可以看到确实是按照从长到短，引用排最后的方式在内存中排列的。按照这种方法我们来重新计算下ObjectA创建的对象的长度:

8(_mark) + 4(oop指针) + 4(i1) + + 4(i2) + 1(b1) + 1(b2) + 1(b3) + 1(padding) +  4(str) + 4(obj) = 32

得到的结果和java.lang.instrument.Instrumentation.getObjectSize()的结果是一样的，证明我们的计算方式是正确的。

sun.misc.Unsafe的方式

下面说一下通过sun.misc.Unsafe对象的objectFieldOffset(field)等方法结合反射来计算对象的大小。基本的思路如下:

1. 通过反射获得一个类的Field

2. 通过Unsafe的objectFieldOffset()获得每个Field的offSet

3. 对Field按照offset排序，取得最大的offset，然后加上这个field的长度，再加上Padding对齐

上面三步就可以获得一个对象的Shallow size。可以进一步通过递归去计算所引用对象的大小，从而可以计算出一个对象所占用的实际大小。

如何获得Unsafe对象已经在这篇中聊聊序列化（二）使用sun.misc.Unsafe绕过new机制来创建Java对象说过了，可以通过反射的机制来获得.

Oop指针是4还是未压缩的8也可以通过unsafe.arrayIndexScale(Object[].class)来获得，这个方法返回一个引用所占用的长度

1. static {
2. try {
3. Field field = Unsafe.class.getDeclaredField("theUnsafe");
4. field.setAccessible(true);
5. unsafe = (Unsafe) field.get(null);
6. objectRefSize = unsafe.arrayIndexScale(Object[].class);
7. } catch (Exception e) {
8. throw new RuntimeException(e);
9. }
10. }

下面的源码摘自 http://java-performance.info/memory-introspection-using-sun-misc-unsafe-and-reflection/， 原文中的代码在计算对象大小的时候有问题，我做了微调，并加上了内存对齐的方法，这样计算出的结果和Instrumentation的getObjectSize方法是一样的。

1. package test;
2. import java.util.ArrayList;
3. import java.util.Collections;
4. import java.util.Comparator;
5. import java.util.List;
6. /**
7. * This class contains object info generated by ClassIntrospector tool
8. * 计算一个Java类对象的大小 1.默认启用了压缩普通对象指针:-XX:+UseCompressedOops 2.这里的计算是包含了值得大小 如:Integer  a =  1; (初始化给值和不给值大小是不一样的)
9. */
10. public class ObjectInfo {
11. /** Field name */
12. public final String name;
13. /** Field type name */
14. public final String type;
15. /** Field data formatted as string */
16. public final String contents;
17. /** Field offset from the start of parent object */
18. public final int offset;
19. /** Memory occupied by this field */
20. public final int length;
21. /** Offset of the first cell in the array */
22. public final int arrayBase;
23. /** Size of a cell in the array */
24. public final int arrayElementSize;
25. /** Memory occupied by underlying array (shallow), if this is array type */
26. public final int arraySize;
27. /** This object fields */
28. public final List<ObjectInfo> children;
29. public ObjectInfo(String name, String type, String contents, int offset, int length, int arraySize,
30. int arrayBase, int arrayElementSize)
31. {
32. this.name = name;
33. this.type = type;
34. this.contents = contents;
35. this.offset = offset;
36. this.length = length;
37. this.arraySize = arraySize;
38. this.arrayBase = arrayBase;
39. this.arrayElementSize = arrayElementSize;
40. children = new ArrayList<ObjectInfo>( 1 );
41. }
42. public void addChild( final ObjectInfo info )
43. {
44. if ( info != null )
45. children.add( info );
46. }
47. /**
48. * Get the full amount of memory occupied by a given object. This value may be slightly less than
49. * an actual value because we don't worry about memory alignment - possible padding after the last object field.
50. *
51. * The result is equal to the last field offset + last field length + all array sizes + all child objects deep sizes
52. * @return Deep object size
53. */
54. public long getDeepSize()
55. {
56. //return length + arraySize + getUnderlyingSize( arraySize != 0 );
57. return addPaddingSize(arraySize + getUnderlyingSize( arraySize != 0 ));
58. }
59. long size = 0;
60. private long getUnderlyingSize( final boolean isArray )
61. {
62. //long size = 0;
63. for ( final ObjectInfo child : children )
64. size += child.arraySize + child.getUnderlyingSize( child.arraySize != 0 );
65. if ( !isArray && !children.isEmpty() ){
66. int tempSize = children.get( children.size() - 1 ).offset + children.get( children.size() - 1 ).length;
67. size += addPaddingSize(tempSize);
68. }
69. return size;
70. }
71. private static final class OffsetComparator implements Comparator<ObjectInfo>
72. {
73. @Override
74. public int compare( final ObjectInfo o1, final ObjectInfo o2 )
75. {
76. return o1.offset - o2.offset; //safe because offsets are small non-negative numbers
77. }
78. }
79. //sort all children by their offset
80. public void sort()
81. {
82. Collections.sort( children, new OffsetComparator() );
83. }
84. @Override
85. public String toString() {
86. final StringBuilder sb = new StringBuilder();
87. toStringHelper( sb, 0 );
88. return sb.toString();
89. }
90. private void toStringHelper( final StringBuilder sb, final int depth )
91. {
92. depth( sb, depth ).append("name=").append( name ).append(", type=").append( type )
93. .append( ", contents=").append( contents ).append(", offset=").append( offset )
94. .append(", length=").append( length );
95. if ( arraySize > 0 )
96. {
97. sb.append(", arrayBase=").append( arrayBase );
98. sb.append(", arrayElemSize=").append( arrayElementSize );
99. sb.append( ", arraySize=").append( arraySize );
100. }
101. for ( final ObjectInfo child : children )
102. {
103. sb.append( '\n' );
104. child.toStringHelper(sb, depth + 1);
105. }
106. }
107. private StringBuilder depth( final StringBuilder sb, final int depth )
108. {
109. for ( int i = 0; i < depth; ++i )
110. sb.append( "\t");
111. return sb;
112. }
113. private long addPaddingSize(long size){
114. if(size % 8 != 0){
115. return (size / 8 + 1) * 8;
116. }
117. return size;
118. }
119. }
120. package test;
121. import java.lang.reflect.Array;
122. import java.lang.reflect.Field;
123. import java.lang.reflect.Modifier;
124. import java.util.ArrayList;
125. import java.util.Arrays;
126. import java.util.Collections;
127. import java.util.HashMap;
128. import java.util.IdentityHashMap;
129. import java.util.List;
130. import java.util.Map;
131. import sun.misc.Unsafe;
132. /**
133. * This class could be used for any object contents/memory layout printing.
134. */
135. public class ClassIntrospector {
136. private static final Unsafe unsafe;
137. /** Size of any Object reference */
138. private static final int objectRefSize;
139. static {
140. try {
141. Field field = Unsafe.class.getDeclaredField("theUnsafe");
142. field.setAccessible(true);
143. unsafe = (Unsafe) field.get(null);
144. objectRefSize = unsafe.arrayIndexScale(Object[].class);
145. } catch (Exception e) {
146. throw new RuntimeException(e);
147. }
148. }
149. /** Sizes of all primitive values */
150. private static final Map<Class, Integer> primitiveSizes;
151. static {
152. primitiveSizes = new HashMap<Class, Integer>(10);
153. primitiveSizes.put(byte.class, 1);
154. primitiveSizes.put(char.class, 2);
155. primitiveSizes.put(int.class, 4);
156. primitiveSizes.put(long.class, 8);
157. primitiveSizes.put(float.class, 4);
158. primitiveSizes.put(double.class, 8);
159. primitiveSizes.put(boolean.class, 1);
160. }
161. /**
162. * Get object information for any Java object. Do not pass primitives to
163. * this method because they will boxed and the information you will get will
164. * be related to a boxed version of your value.
165. *
166. * @param obj
167. *            Object to introspect
168. * @return Object info
169. * @throws IllegalAccessException
170. */
171. public ObjectInfo introspect(final Object obj)
172. throws IllegalAccessException {
173. try {
174. return introspect(obj, null);
175. } finally { // clean visited cache before returning in order to make
176. // this object reusable
177. m_visited.clear();
178. }
179. }
180. // we need to keep track of already visited objects in order to support
181. // cycles in the object graphs
182. private IdentityHashMap<Object, Boolean> m_visited = new IdentityHashMap<Object, Boolean>(
183. 100);
184. private ObjectInfo introspect(final Object obj, final Field fld)
185. throws IllegalAccessException {
186. // use Field type only if the field contains null. In this case we will
187. // at least know what's expected to be
188. // stored in this field. Otherwise, if a field has interface type, we
189. // won't see what's really stored in it.
190. // Besides, we should be careful about primitives, because they are
191. // passed as boxed values in this method
192. // (first arg is object) - for them we should still rely on the field
193. // type.
194. boolean isPrimitive = fld != null && fld.getType().isPrimitive();
195. boolean isRecursive = false; // will be set to true if we have already
196. // seen this object
197. if (!isPrimitive) {
198. if (m_visited.containsKey(obj))
199. isRecursive = true;
200. m_visited.put(obj, true);
201. }
202. final Class type = (fld == null || (obj != null && !isPrimitive)) ? obj
203. .getClass() : fld.getType();
204. int arraySize = 0;
205. int baseOffset = 0;
206. int indexScale = 0;
207. if (type.isArray() && obj != null) {
208. baseOffset = unsafe.arrayBaseOffset(type);
209. indexScale = unsafe.arrayIndexScale(type);
210. arraySize = baseOffset + indexScale * Array.getLength(obj);
211. }
212. final ObjectInfo root;
213. if (fld == null) {
214. root = new ObjectInfo("", type.getCanonicalName(), getContents(obj,
215. type), 0, getShallowSize(type), arraySize, baseOffset,
216. indexScale);
217. } else {
218. final int offset = (int) unsafe.objectFieldOffset(fld);
219. root = new ObjectInfo(fld.getName(), type.getCanonicalName(),
220. getContents(obj, type), offset, getShallowSize(type),
221. arraySize, baseOffset, indexScale);
222. }
223. if (!isRecursive && obj != null) {
224. if (isObjectArray(type)) {
225. // introspect object arrays
226. final Object[] ar = (Object[]) obj;
227. for (final Object item : ar)
228. if (item != null)
229. root.addChild(introspect(item, null));
230. } else {
231. for (final Field field : getAllFields(type)) {
232. if ((field.getModifiers() & Modifier.STATIC) != 0) {
233. continue;
234. }
235. field.setAccessible(true);
236. root.addChild(introspect(field.get(obj), field));
237. }
238. }
239. }
240. root.sort(); // sort by offset
241. return root;
242. }
243. // get all fields for this class, including all superclasses fields
244. private static List<Field> getAllFields(final Class type) {
245. if (type.isPrimitive())
246. return Collections.emptyList();
247. Class cur = type;
248. final List<Field> res = new ArrayList<Field>(10);
249. while (true) {
250. Collections.addAll(res, cur.getDeclaredFields());
251. if (cur == Object.class)
252. break;
253. cur = cur.getSuperclass();
254. }
255. return res;
256. }
257. // check if it is an array of objects. I suspect there must be a more
258. // API-friendly way to make this check.
259. private static boolean isObjectArray(final Class type) {
260. if (!type.isArray())
261. return false;
262. if (type == byte[].class || type == boolean[].class
263. || type == char[].class || type == short[].class
264. || type == int[].class || type == long[].class
265. || type == float[].class || type == double[].class)
266. return false;
267. return true;
268. }
269. // advanced toString logic
270. private static String getContents(final Object val, final Class type) {
271. if (val == null)
272. return "null";
273. if (type.isArray()) {
274. if (type == byte[].class)
275. return Arrays.toString((byte[]) val);
276. else if (type == boolean[].class)
277. return Arrays.toString((boolean[]) val);
278. else if (type == char[].class)
279. return Arrays.toString((char[]) val);
280. else if (type == short[].class)
281. return Arrays.toString((short[]) val);
282. else if (type == int[].class)
283. return Arrays.toString((int[]) val);
284. else if (type == long[].class)
285. return Arrays.toString((long[]) val);
286. else if (type == float[].class)
287. return Arrays.toString((float[]) val);
288. else if (type == double[].class)
289. return Arrays.toString((double[]) val);
290. else
291. return Arrays.toString((Object[]) val);
292. }
293. return val.toString();
294. }
295. // obtain a shallow size of a field of given class (primitive or object
296. // reference size)
297. private static int getShallowSize(final Class type) {
298. if (type.isPrimitive()) {
299. final Integer res = primitiveSizes.get(type);
300. return res != null ? res : 0;
301. } else
302. return objectRefSize;
303. }
304. }

先一个测试类来验证一下Unsafe的方式计算出的结果

1. public class ClassIntrospectorTest
2. {
3. public static void main(String[] args) throws IllegalAccessException {
4. final ClassIntrospector ci = new ClassIntrospector();
5. ObjectInfo res;
6. res = ci.introspect( new ObjectA() );
7. System.out.println( res.getDeepSize() );
8. }
9. private static class ObjectA {
10. String str;  // 4
11. int i1; // 4
12. byte b1; // 1
13. byte b2; // 1
14. int i2;  // 4
15. ObjectB obj; //4
16. byte b3;  // 1
17. }
18. private static class ObjectB {
19. }
20. }

计算结果如下：

32

和我们之前计算结果是一致的，证明是正确的。

最后再来测试一下数组对象的长度。有两个类如下:

1. private static class ObjectC {
2. ObjectD[] array = new ObjectD[2];
3. }
4. private static class ObjectD {
5. int value;
6. }

它们在内存的大体分布如下图:

我们可以手工计算一下ObjectC obj = new ObjectC()的大小：

ObjectC的Shallow size = 8(_mark) + 4(oop指针)  + 4(ObjectD[]引用) = 16

new ObjectD[2]数组的长度 =  8(_mark) + 4(oop指针) + 4(数组长度占4个字节) + 4(ObjectD[0]引用) + 4(ObjectD[1]引用) = 24

由于ObjectD[]数组没有指向具体的对象大小，所以我们手工计算的结果是16 + 24 = 40

使用Unsafe对象的方式来计算一下:

1. public static void main(String[] args) throws IllegalAccessException {
2. final ClassIntrospector ci = new ClassIntrospector();
3. ObjectInfo res;
4. res = ci.introspect( new ObjectC() );
5. System.out.println( res.getDeepSize() );
6. }

计算结果如下，和我们计算的结果是一致的，证明是正确的:

40

再给ObjectD[]数组指向具体的ObjectD对象，再测试一下结果：

1. public static void main(String[] args) throws IllegalAccessException {
2. final ClassIntrospector ci = new ClassIntrospector();
3. ObjectInfo res;
4. res = ci.introspect( new ObjectC() );
5. System.out.println( res.getDeepSize() );
6. }
7. private static class ObjectC {
8. ObjectD[] array = new ObjectD[2];
9. public ObjectC(){
10. array[0] = new ObjectD();
11. array[1] = new ObjectD();
12. }
13. }
14. private static class ObjectD {
15. int value;
16. }

我们可以手工计算一下ObjectC obj = new ObjectC()的大小：

ObjectC的Shallow size = 8(_mark) + 4(oop指针)  + 4(ObjectD[]引用) = 16

new ObjectD[2]数组的长度 =  8(_mark) + 4(oop指针) + 4(数组长度占4个字节) + 4(ObjectD[0]引用) + 4(ObjectD[1]引用) = 24

ObjectD对象长度 = 8(_mark) + 4(oop指针) + 4(value) = 16

所以ObjectC实际占用的空间 = 16 + 24 + 2 * 16 = 72

使用Unsafe的方式计算的结果也是72，和我们手工计算的方式一致。

其他参考链接:https://segmentfault.com/a/1190000004574249