BothLog

1: public class SizeOfAgent {
2: 
3:         static Instrumentation inst;
4:         
5:         /** initializes agent */
6:         public static void premain(String agentArgs, Instrumentation instP) {
7:                 inst = instP;           
8:         }
9: }

permain方法会在启动的时候被JVM调用，Instrumentation的实例被传入。SizeOfAgent类使用静态变量保存Instrumentation对象的引用。为了让JVM知道instrumentation代理类的存在，必须将其打包进JAR文件并且设定manifest.mf文件中的属性。在我们的例子中，需要设定如下属性：

Premain-Class: sizeof.agent.SizeOfAgent
Boot-Class-Path:
Can-Redefine-Classes: false

另外，Java程序必须使用 -javaagent 参数指向该jar文件来启动。我们的例子中形如：

在获得了Instrumentation对象的引用之后，实现一个sizeOf方法变得很简单。

1: public class SizeOfAgent {
2: 
3:         static Instrumentation inst;
4:         
5:         // ...
6:                 
7:         public static long sizeOf(Object o) {
8:                 return inst.getObjectSize(o);
9:         }
10: }

SizeOgAgent.sizeOf()方法能方便的被你的程序所调用。如前面所提到的，这个方法仅返回某个对象的大小而不包括其成员变量。完整的对象大小能通过反射得到。我们能通过简单的递归遍历所有的成员变量来总计他们的大小。并不是所有人都知道能够通过反射访问private和protected变量。你仅仅需要在获得private成员之前调用 Field.setAccessible(true) 方法即可。下面是SizeOfAgent类中fullSizeOf方法完整实现的源码：

001: package sizeof.agent;
002: 
003: import java.lang.instrument.Instrumentation;
004: import java.lang.reflect.Array;
005: import java.lang.reflect.Field;
006: import java.lang.reflect.Modifier;
007: import java.util.IdentityHashMap;
008: import java.util.Map;
009: import java.util.Stack;
010: 
011: /** Instrumentation agent used */
012: public class SizeOfAgent {
013: 
014:         static Instrumentation inst;
015:         
016:         /** initializes agent */
017:         public static void premain(String agentArgs, Instrumentation instP) {
018:                 inst = instP;           
019:         }
020:         
021:         /**
022:          * Returns object size without member sub-objects.
023:          * @param o object to get size of
024:          * @return object size
025:          */
026:         public static long sizeOf(Object o) {
027:                 if(inst == null) {
028:                         throw new IllegalStateException("Can not access instrumentation environment.\n" +
029:                                         "Please check if jar file containing SizeOfAgent class is \n" +
030:                                         "specified in the java's \"-javaagent\" command line argument.");
031:                 }
032:                 return inst.getObjectSize(o);
033:         }
034:         
035:         /**
036:          * Calculates full size of object iterating over
037:          * its hierarchy graph.
038:          * @param obj object to calculate size of
039:          * @return object size
040:          */
041:         public static long fullSizeOf(Object obj) {
042:                 Map<Object, Object> visited = new IdentityHashMap<Object, Object>();
043:                 Stack<Object> stack = new Stack<Object>();
044: 
045:             long result = internalSizeOf(obj, stack, visited);
046:             while (!stack.isEmpty()) {
047:               result += internalSizeOf(stack.pop(), stack, visited);
048:             }
049:             visited.clear();
050:             return result;
051:         }               
052:           
053:     private static boolean skipObject(Object obj, Map<Object, Object> visited) {
054:             if (obj instanceof String) {
055:               // skip interned string
056:               if (obj == ((String) obj).intern()) {
057:                 return true;
058:               }
059:             }
060:             return (obj == null) // skip visited object
061:                 || visited.containsKey(obj);
062:          }
063: 
064:     private static long internalSizeOf(Object obj, Stack<Object> stack, Map<Object, Object> visited) {
065:             if (skipObject(obj, visited)){
066:                 return 0;
067:             }
068:             visited.put(obj, null);
069:             
070:             long result = 0;
071:             // get size of object + primitive variables + member pointers 
072:             result += SizeOfAgent.sizeOf(obj);
073:             
074:             // process all array elements
075:             Class clazz = obj.getClass();
076:             if (clazz.isArray()) {
077:               if(clazz.getName().length() != 2) {// skip primitive type array
078:                   int length =  Array.getLength(obj);
079:                           for (int i = 0; i < length; i++) {
080:                                   stack.add(Array.get(obj, i));
081:                       } 
082:               }       
083:               return result;
084:             }
085:             
086:             // process all fields of the object
087:             while (clazz != null) {
088:               Field[] fields = clazz.getDeclaredFields();
089:               for (int i = 0; i < fields.length; i++) {
090:                 if (!Modifier.isStatic(fields[i].getModifiers())) {
091:                   if (fields[i].getType().isPrimitive()) {
092:                           continue; // skip primitive fields
093:                   } else {
094:                     fields[i].setAccessible(true);
095:                     try {
096:                       // objects to be estimated are put to stack
097:                       Object objectToAdd = fields[i].get(obj);
098:                       if (objectToAdd != null) {                        
099:                         stack.add(objectToAdd);
100:                       }
101:                     } catch (IllegalAccessException ex) { 
102:                         assert false; 
103:                     }
104:                   }
105:                 }
106:               }
107:               clazz = clazz.getSuperclass();
108:             }
109:             return result;
110:          }
111: }

基本思想类似于Dr. Heinz M. Kabutz的方法:http://www.javaspecialists.co.za/archive/Issue078.html.我甚至重用了他的skipObject方法。该算法用来保证每个对象仅被统计一次，防止循环引用。另外它忽略了intern类型的String（详细参加 String.intern()）。

这个方法的主要缺点是不能用于沙箱环境类似于applet或者Web Start程序。这个限制是因为通过反射访问私有成员的方法和instrumentation代理在沙箱环境中无效。

文件 sizeofag.jar 包含编译好的class文件和java源码。你可以仅仅将sizeofag.jar通过-javaagent参数添加进JVM中，在你的程序中像使用普通类一样使用SizeOfAgent类。好好享受它吧:)