精確計算一個Java對象佔用的記憶體大小

《java最佳化佔用記憶體的方法 -- 雪的痕迹》一文中提到：

 

" java做的系統給人的印象是什嗎？占記憶體！說道這句話就會有N多人站出來為java辯護，並舉出一堆的效能測試報告來證明這一點。其實從理論上來講java做的系統並不比其他語言開發出來的系統更佔用記憶體，那麼為什麼卻有這麼N多理由來證明它確實占記憶體呢？兩個字，陋習"

 

那如何衡量對象佔用的記憶體空間大小呢？有人可能會說簡單的使用如下代碼：

 

gc();

Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();

 

然而這樣做只能計算出堆中所有執行個體佔用的記憶體大小，無法做到對一個對象的精確計算，

 

本人寫了一段小代碼計算對象的記憶體佔用量，得出的結果和自己的電腦上記憶體的使用量一樣，電腦配置是64位CPU，裝32位XP作業系統，32位sun的虛擬機器(參數-client)，記憶體3G，不清楚程式是否通用。

 

演算法簡述：

1.實值型別變數佔用大小已知

2.參考型別變數佔用大小4位元組（還沒有在64位JVM下測試過），如Object x = null;  這個x變數在32位jvm中測得佔用4位元組

3.對象大小與佔用空間的關係：occupy = (size + 8 - 1) / 8 * 8;

4.遞迴的遍曆一個對象內的所有成員變數，成員變數的成員變數的佔用的記憶體大小，

 

(目前無法對包含private java.lang.reflect.Constructot類型的成員的對象計算大小，因為無法通過反射獲得對象該欄位的值)。

 

 

 

 

import java.lang.reflect.*;

import java.util.*;

 

//一個引用：4位元組

//一個Object：8位元組

//一個Integer：16位元組 == (8 + 4) / 8 * 8

//一個int：4位元組

//長度為0的數組大小：JRo64=24,  Sun32=12

 

//引用大小，如Object = null：                    JRo64=JRo32=4, Sun32=4, Sun64=8

//無成員的對象大小，如new Object();：     JRo32=JRo64=8, Sun32=8, Sun64=16

//new byte[0]:                        JRo32=JRo64=8+8 Sun32=8+4, Sun64=16+8

 

//長度l的byte數組：(l+19)/8*8

//長度l的char/short數組：(l*2+19)/8*8 == (l+9)/4*8

//長度l的String：(l+1)/4*8+40

//長度l的int數組：(l*4+19)/8*8 ==(l+4)/2*8

//長度l的long數組：(l*8+19)/8*8 == (l+2)*8

public class Occupy {

 

  //這8個方法不寫不行，否則occupyof(int x)會自動重載到occupyof(Object o),並且無法在方法中判斷

  public static int occupyof(boolean variable) {

    return 1;

  }

 

  public static int occupyof(byte variable) {

    return 1;

  }

 

  public static int occupyof(short variable) {

    return 2;

  }

 

  public static int occupyof(char variable) {

    return 2;

  }

 

  public static int occupyof(int variable) {

    return 4;

  }

 

  public static int occupyof(float variable) {

    return 4;

  }

 

  public static int occupyof(long variable) {

    return 8;

  }

 

  public static int occupyof(double variable) {

    return 8;

  }

 

  public Occupy(byte nullReferenceSize, byte emptyObjectSize, byte emptyArrayVarSize) {

    this.NULL_REFERENCE_SIZE = nullReferenceSize;

    this.EMPTY_OBJECT_SIZE = emptyObjectSize;

    this.EMPTY_ARRAY_VAR_SIZE = emptyArrayVarSize;

  }

 

  public static Occupy forJRockitVM() {

    return new Occupy((byte) 4, (byte) 8, (byte) 8);

  }

 

  public static Occupy forSun32BitsVM() {

    return new Occupy((byte) 4, (byte) 8, (byte) 4);

  }

 

  public static Occupy forSun64BitsVM() {

    return new Occupy((byte) 8, (byte) 16, (byte) 8);

  }

 

  public static Occupy forDetectedVM(){

    return null;

  }

 

  private final byte NULL_REFERENCE_SIZE;

  private final byte EMPTY_OBJECT_SIZE;

  private final byte EMPTY_ARRAY_VAR_SIZE;

 

  private static class ref{

    public ref(Object obj){

      this.obj = obj;

    }

    final Object obj;

    @Override

    public boolean equals(Object obj) {

      return (obj instanceof ref) && ((ref)obj).obj == this.obj;

    }

    @Override

    public int hashCode() {

      return obj.hashCode();

    }

  }

 

  private List dedup = new ArrayList();

  /**

   * 對象佔用的記憶體空間，對象佔用空間與對象的大小並不相等，就好象Windows下檔案一樣(大小為1位元組時佔用空間4k)

   * @param object

   * @return

   */

  public int occupyof(Object object){

    dedup.clear();

    return occupyof0(object);

  }

  private int occupyof0(Object object) {

    if (object == null)

      return 0;

    ref r = new ref(object);

    if(dedup.contains(r))

      return 0;

    dedup.add(r);

    int varSize = 0;//對象中的實值型別、參考型別變數大小

    int objSize = 0;//對象中的參考型別指向的對象執行個體的大小

    for (Class clazz = object.getClass(); clazz != Object.class; clazz = clazz.getSuperclass()) {

//    

 System.out.println(clazz);

      if (clazz.isArray()) {//當前對象的數組

        varSize += EMPTY_ARRAY_VAR_SIZE;

        Class<?> componentType = clazz.getComponentType();

        if (componentType.isPrimitive()) {//當前數組是原生類型的數組

          varSize += lengthOfPrimitiveArray(object) * sizeofPrimitiveClass(componentType);

          return occupyOfSize(EMPTY_OBJECT_SIZE, varSize, 0);

        }

        Object[] array = (Object[]) object;

        varSize += NULL_REFERENCE_SIZE * array.length;//當前數組有length個引用，每個佔用4位元組

        for (Object o : array)

          objSize += occupyof0(o);

        return occupyOfSize(EMPTY_OBJECT_SIZE, varSize, objSize);

      }

      Field[] fields = clazz.getDeclaredFields();

      for (Field field : fields) {

        if (Modifier.isStatic(field.getModifiers()))

          continue;//類成員不計

        //System.out.println(field.getDeclaringClass());

        if(clazz != field.getDeclaringClass())

          continue;

        Class<?> type = field.getType();

        if (type.isPrimitive())

          varSize += sizeofPrimitiveClass(type);

        else {

          varSize += NULL_REFERENCE_SIZE;//一個引用型變數佔用4個位元組

          try {

            field.setAccessible(true);//可以訪問非public類型的變數

              objSize += occupyof0(field.get(object));

          } catch (Exception e) {

            objSize += occupyofConstructor(object, field);

          }

        }

      }

    }

    return occupyOfSize(EMPTY_OBJECT_SIZE, varSize, objSize);

  }

 

  public static int sizeof(boolean variable) {

    return 1;

  }

 

  public static int sizeof(byte variable) {

    return 1;

  }

 

  public static int sizeof(short variable) {

    return 2;

  }

 

  public static int sizeof(char variable) {

    return 2;

  }

 

  public static int sizeof(int variable) {

    return 4;

  }

 

  public static int sizeof(float variable) {

    return 4;

  }

 

  public static int sizeof(long variable) {

    return 8;

  }

 

  public static int sizeof(double variable) {

    return 8;

  }

 

  /**

   * 對象的大小

   * @param object

   * @return

   */

  public int sizeof(Object object) {

    if (object == null)

      return 0;

    int size = EMPTY_OBJECT_SIZE;

    Class clazz = object.getClass();

    if (clazz.isArray()) {

      size += EMPTY_ARRAY_VAR_SIZE;//length變數是int型

      Class<?> componentType = clazz.getComponentType();

      if (componentType.isPrimitive())

        return size + lengthOfPrimitiveArray(object) * sizeofPrimitiveClass(componentType);

      Object[] array = (Object[]) object;

      size += 4 * array.length;

      for (Object o : array)

        size += sizeof(o);

      return size;

    }

    Field[] fields = clazz.getDeclaredFields();

    for (Field field : fields) {

      if (Modifier.isStatic(field.getModifiers()))

        continue;//類成員不計

      Class<?> type = field.getType();

      if (type.isPrimitive())

        size += sizeofPrimitiveClass(type);

      else {

        size += 4;//一個引用型變數佔用4個位元組

        try {

          field.setAccessible(true);//可以訪問非public類型的變數

          size += sizeof(field.get(object));

        } catch (Exception e) {

          size += sizeofConstructor(object, field);

        }

      }

    }

    return size;

  }

 

  private static int occupyofConstructor(Object object, Field field) {

    throw new UnsupportedOperationException("field type Constructor not accessible: " + object.getClass() + " field:" + field);

  }

 

  private static int sizeofConstructor(Object object, Field field) {

    throw new UnsupportedOperationException("field type Constructor not accessible: " + object.getClass() + " field:" + field);

  }

 

  /**

   * 對象的大小 和 佔用空間並不相等，就好象Windows下檔案一樣(大小為1位元組時佔用空間4k)

   * 對象佔用空間的增長以8個位元組為單位，佔用空間=大小對8的無條件進位法，

   * 即occupy = (size + 8 - 1) / 8 * 8;   例如：

   * 大小8位元組：佔用8位元組，(new Object()就是佔用8位元組)

   * 大小9位元組：佔用16位元組

   * 大小16位元組：佔用16位元組

   * 大小17位元組：佔用24位元組

   * @param size 大小，以位元組為單位

   * @return 佔用空間

   */

  private static int occupyOfSize(int size) {

    return (size + 7) / 8 * 8;

  }

 

  private static int occupyOfSize(int selfSize, int varsSize, int objsSize) {

//    System.out.println("self=" + selfSize + " vars=" + varsSize + " objs=" + objsSize);

    return occupyOfSize(selfSize) + occupyOfSize(varsSize) + objsSize;

  }

 

  private static int sizeofPrimitiveClass(Class clazz) {

    return clazz == boolean.class || clazz == byte.class ? 1 : clazz == char.class || clazz == short.class ? 2 : clazz == int.class || clazz == float.class ? 4

        : 8;

  }

 

  private static int lengthOfPrimitiveArray(Object object) {

    Class<?> clazz = object.getClass();

    return clazz == boolean[].class ? ((boolean[]) object).length : clazz == byte[].class ? ((byte[]) object).length

        : clazz == char[].class ? ((char[]) object).length : clazz == short[].class ? ((short[]) object).length

            : clazz == int[].class ? ((int[]) object).length : clazz == float[].class ? ((float[]) object).length

                : clazz == long[].class ? ((long[]) object).length : ((double[]) object).length;

  }

}