JVM对象占用内存计算工具--SizeOf源码分析

SizeOf是一个用于计算JVM堆中对象所占用内存的小工具，使用起来很方便。今天没事把源码down下来看了看，同时写了个笔记贴上来，希望对看到的人有所帮助。

-----------------------------------

SizeOf主要思路是通过jdk1.5提供的新特性Instrumentation计算对象占用内存大小。

jdk文档中java.lang.instrument.Instrumentation介绍：

此类提供检测 Java 编程语言代码所需的服务。检测是向方法中添加字节码，以搜集各种工具所使用的数据。由于更改完全是进行添加，所以这些工具不修改应用程序的状态或行为。这种无害工具的例子包括镜像代理、分析器、覆盖分析器和事件记录器。

源码分析：

项目主页：http://sourceforge.net/projects/sizeof/ 

整个源码只有一个类SizeOf.java，重点是sizeOf和deepSizeOf两个方法。

1、premain：

通过premain注入VM中Instrumentation实例。

private static Instrumentation inst;
public static void premain(String options, Instrumentation inst)
{
	SizeOf.inst = inst;
	System.out.println("JAVAGENT: call premain instrumentation for class SizeOf");
}

JVM以代理类方式启动时，回调premain方法，并注入Instrumentation实例。

2、sizeOf：

计算一个对象的大小，但该对象内引用的其它对象的大小不计算在内。

首先，SizeOf类内有3个与计算对象大小相关的开关：

private static boolean SKIP_STATIC_FIELD = false;//是否计算static属性
private static boolean SKIP_FINAL_FIELD = false;//是否计算final属性
private static boolean SKIP_FLYWEIGHT_FIELD = false;//是否计算共享(享元)对象

sizeOf方法：

public static long sizeOf(Object object)
{
	if (inst == null)
		throw new IllegalStateException("Instrumentation is null");
	//是否计算共享对象
	if (SKIP_FLYWEIGHT_FIELD && isSharedFlyweight(object))
		return 0;
	return inst.getObjectSize(object);
}

该方法内部直接通过Instrumentation的getObjectSize方法计算当前传入对象占用内存的大小，需要注意的是，这里有一个isSharedFlyweight方法：

private static boolean isSharedFlyweight(Object obj)
{
		// optimization - all of our flyweights are Comparable
		if (obj instanceof Comparable)
		{
			if (obj instanceof Enum)
			{
				return true;
			} else if (obj instanceof String)
			{
				return (obj == ((String) obj).intern()); 
			} else if (obj instanceof Boolean)
			{
				return (obj == Boolean.TRUE || obj == Boolean.FALSE);
			} else if (obj instanceof Integer)
			{
				return (obj == Integer.valueOf((Integer) obj)); 
			} else if (obj instanceof Short)
			{
				return (obj == Short.valueOf((Short) obj));
			} else if (obj instanceof Byte)
			{
				return (obj == Byte.valueOf((Byte) obj));
			} else if (obj instanceof Long)
			{
				return (obj == Long.valueOf((Long) obj));
			} else if (obj instanceof Character)
			{
				return (obj == Character.valueOf((Character) obj));
			}
		}
		return false;
}

该方法的作用是判断传入对象是否为享元对象，可以理解为共享一块内存区域的对象，这部分内存可以不进行计算统计(因为每个对象都共同使用一块内存)。所有享元对象都实现了Comparable接口。

(1)关于String.intern()：String类内部维护着一个字符串池，如果池中包含一个等于此字符串的对象，则返回池中对象，否则将此String对象添加到池中，并返回此String对象的引用。intern()方法会从字符串池中取出与这个字符串内容相同的字符串对象，也就是说String.intern()返回的是空享内存空间的对象。

(2)关于基本数据类型：

至于Boolean、Integer、Short、Byte...等基本数据类型包装的对象怎么也会被算作共享内存区域呢？查了一些资料，原因是这样的：就拿Integer类来说，它会缓存了-128到127这256个状态的Integer值，如果使用Integer.valueOf(int i)，传入的int范围正好在此内，就返回静态实例。

也就是说，如果你使用了Integer.valueOf()时，有可能直接返回静态实例。

可见在日常编程中，能用Boolean.TRUE或FALSE就不要用new Boolean()，能用Integer.valueOf的时候就不要用new Integer()，其它各数据类型也都如此。

如果传入对象内部属性有引用其它对象时，sizeOf方法不计算引用对象的大小(详见deepSizeOf)。

3、deepSizeOf方法：

public static long deepSizeOf(Object objectToSize)
{
	//Set<Integer> doneObj = new HashSet<Integer>();
	Map<Object,Object> doneObj = new IdentityHashMap<Object,Object>();
	return deepSizeOf(objectToSize, doneObj, 0);
}

首先声明了一个IdentityHashMap，jdk文档中关于IdentityHashMap的解释：

此类利用哈希表实现Map接口，比较键（和值）时使用引用相等性代替对象相等性。换句话说，在 IdentityHashMap中，当且仅当(k1==k2)时，才认为两个键k1和k2相等。

然后是deepSizeOf的重载方法，这个方法有点长，分段来解析。

private static long deepSizeOf(Object o, Map<Object,Object> doneObj, int depth)
{
		if (o == null)
		{
			if (debug)
				print("null\n");
			return 0;
		}
		long size = 0;
		if (doneObj.containsKey(o))
		{
			if (debug)
				print("\n%s{ yet computed }\n", indent(depth));
			return 0;
		}
		if (debug)
			print("\n%s{ %s\n", indent(depth), o.getClass().getName());
		doneObj.put(o,null);//从引用map中获取该属性
		size = sizeOf(o);//计算obj的大小
                //...

如果传入对象的引用在IdentityHashMap中已经包含，说明已经计算过该对象，则返回0，否则直接将该引用放入IdentityHashMap之后直接调用sizeOf方法计算对象大小。

if (o instanceof Object[])//对象为数组
{
	int i = 0;
	for (Object obj : (Object[]) o)
	{
		if (debug)
		print("%s [%d] = ", indent(depth), i++);
		//取数组中的每个元素,递归调用
		size += deepSizeOf(obj, doneObj, depth + 1);
	}
} else

 如果对象为数组，则取数组的每个元素递归调用deepSizeOf方法，计算每个对象大小。

else //该对象不为数组
{
	//获取每个属性
	Field[] fields = o.getClass().getDeclaredFields();
	//遍历每个属性
	for (Field field : fields)
	{
		//值为true则指示反射的对象在使用时应该取消Java语言访问检查
		field.setAccessible(true);
		Object obj;
		try
		{
			obj = field.get(o);//取出该属性在对象上的值
		} catch (IllegalArgumentException e)
		{
			throw new RuntimeException(e);
		} catch (IllegalAccessException e)
		{
			throw new RuntimeException(e);
		}
		//判断该属性是否可计算
		if (isComputable(field))
		{
			if (debug)
				print("%s %s = ", indent(depth), field.getName());
			size += deepSizeOf(obj, doneObj, depth + 1);//递归调用计算各属性对象大小
		} else
		{
			if (debug)
				print("%s %s = %s\n", indent(depth), field.getName(), obj.toString());
		}
	}
}

如果传入对象不为数组，则遍历每个属性，取出每个属性在对象上的值，然后判断该属性是否可被计算，如果可以，则递归调用deepSizeOf方法，累加size大小。

这里有一个方法isComputable如下：

private static boolean isComputable(Field field)
{
		int modificatori = field.getModifiers();
		if (isAPrimitiveType(field.getType()))
			return false;
		else if (SKIP_STATIC_FIELD && Modifier.isStatic(modificatori))
			return false;
		else if (SKIP_FINAL_FIELD && Modifier.isFinal(modificatori))
			return false;
		else
			return true;
}

对3种类型的属性进行判断：原始类型的包装类型、static类型和final类型。其中后两种可有开关控制，第一种由于在sizeOf方法中的getObjectSize计算过了，此处不需要重复计算。

至此，deepSizeOf部分的代码也分析完了。

结束语：

今天对SizeOf的源码分析就先告一段落，希望对看到的人有所帮助。

关于开源工具SizeOf，这里还有我的另一篇Blog，欢迎多提些建议。

使用SizeOf测定JVM中对象占用内存： http://shensy.iteye.com/blog/1765760