new Java對象佔用內存分析

最近在讀《深刻理解Java虛擬機》，對Java對象的內存佈局有了進一步的認識，因而腦子裏天然而然就有一個很普通的問題，就是一個Java對象到底佔用多大內存？

在網上搜到了一篇博客講的很是好：http://yueyemaitian.iteye.com/blog/2033046，裏面提供的這個類也很是實用：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99

importjava.lang.instrument.Instrumentation;  importjava.lang.reflect.Array;  importjava.lang.reflect.Field;  importjava.lang.reflect.Modifier;  importjava.util.ArrayDeque;  importjava.util.Deque;  importjava.util.HashSet;  importjava.util.Set;      /**  * 對象佔用字節大小工具類  *  * @author tianmai.fh  * @date 2014-03-18 11:29  */  publicclassSizeOfObject {      staticInstrumentation inst;          publicstaticvoidpremain(String args, Instrumentation instP) {          inst = instP;      }          /**      * 直接計算當前對象佔用空間大小，包括當前類及超類的基本類型實例字段大小、</br>      * 引用類型實例字段引用大小、實例基本類型數組總佔用空間、實例引用類型數組引用自己佔用空間大小;</br>      * 可是不包括超類繼承下來的和當前類聲明的實例引用字段的對象自己的大小、實例引用數組引用的對象自己的大小 </br>      *      * @param obj      * @return      */      publicstaticlongsizeOf(Object obj) {          returninst.getObjectSize(obj);      }          /**      * 遞歸計算當前對象佔用空間總大小，包括當前類和超類的實例字段大小以及實例字段引用對象大小      *      * @param objP      * @return      * @throws IllegalAccessException      */      publicstaticlongfullSizeOf(Object objP)throwsIllegalAccessException {          Set<Object> visited =newHashSet<Object>();          Deque<Object> toBeQueue =newArrayDeque<Object>();          toBeQueue.add(objP);          longsize = 0L;          while(toBeQueue.size() >0) {              Object obj = toBeQueue.poll();              //sizeOf的時候已經計基本類型和引用的長度，包括數組              size += skipObject(visited, obj) ? 0L : sizeOf(obj);              Class<?> tmpObjClass = obj.getClass();              if(tmpObjClass.isArray()) {                  //[I , [F 基本類型名字長度是2                  if(tmpObjClass.getName().length() >2) {                      for(inti =0, len = Array.getLength(obj); i < len; i++) {                          Object tmp = Array.get(obj, i);                          if(tmp !=null) {                              //非基本類型須要深度遍歷其對象                              toBeQueue.add(Array.get(obj, i));                          }                      }                  }              }else{                  while(tmpObjClass !=null) {                      Field[] fields = tmpObjClass.getDeclaredFields();                      for(Field field : fields) {                          if(Modifier.isStatic(field.getModifiers())  //靜態不計                                  || field.getType().isPrimitive()) {   //基本類型不重複計                              continue;                          }                              field.setAccessible(true);                          Object fieldValue = field.get(obj);                          if(fieldValue ==null) {                              continue;                          }                          toBeQueue.add(fieldValue);                      }                      tmpObjClass = tmpObjClass.getSuperclass();                  }              }          }          returnsize;      }          /**      * String.intern的對象不計；計算過的不計，也避免死循環      *      * @param visited      * @param obj      * @return      */      staticbooleanskipObject(Set<Object> visited, Object obj) {          if(objinstanceofString && obj == ((String) obj).intern()) {              returntrue;          }          returnvisited.contains(obj);      }  }

你們能夠用這個代碼邊看邊驗證，注意的是，運行這個程序須要經過javaagent注入Instrumentation，具體能夠看原博客。我今天主要是總結下手動計算Java對象佔用字節數的基本規則，作爲基本的技能必須get√，但願能幫到和我同樣的Java菜鳥。

在介紹以前，簡單回顧下，Java對象的內存佈局：對象頭（Header），實例數據（Instance Data）和對齊填充（Padding），詳細的能夠看個人讀書筆記。另外：不一樣的環境結果可能有差別，我所在的環境是HotSpot虛擬機，64位Windwos。

下面進入正文：

對象頭

對象頭在32位系統上佔用8bytes，64位系統上佔用16bytes。

實例數據

原生類型(primitive type)的內存佔用以下：

Primitive Type	Memory Required(bytes)
boolean	1
byte	1
short	2
char	2
int	4
float	4
long	8
double	8

reference類型在32位系統上每一個佔用4bytes, 在64位系統上每一個佔用8bytes。

對齊填充

HotSpot的對齊方式爲8字節對齊：

（對象頭 + 實例數據 + padding） % 8等於0且0 <= padding < 8

指針壓縮

對象佔用的內存大小收到VM參數UseCompressedOops的影響。

1）對對象頭的影響

開啓（-XX:+UseCompressedOops）對象頭大小爲12bytes（64位機器）。

1 2 3

staticclassA {         inta;     }

A對象佔用內存狀況：

關閉指針壓縮： 16+4=20不是8的倍數，因此+padding/4=24

開啓指針壓縮： 12+4=16已是8的倍數了，不須要再padding。

2） 對reference類型的影響

64位機器上reference類型佔用8個字節，開啓指針壓縮後佔用4個字節。

1 2 3 4

staticclassB2 {         intb2a;         Integer b2b; }

B2對象佔用內存狀況：

關閉指針壓縮： 16+4+8=28不是8的倍數，因此+padding/4=32

開啓指針壓縮： 12+4+4=20不是8的倍數，因此+padding/4=24

數組對象

64位機器上，數組對象的對象頭佔用24個字節，啓用壓縮以後佔用16個字節。之因此比普通對象佔用內存可能是由於須要額外的空間存儲數組的長度。

先考慮下new Integer[0]佔用的內存大小，長度爲0，便是對象頭的大小：

未開啓壓縮：24bytes

開啓壓縮後：16bytes

接着計算new Integer[1]，new Integer[2]，new Integer[3]和new Integer[4]就很容易了：

未開啓壓縮：

開啓壓縮：

拿new Integer[3]來具體解釋下：

未開啓壓縮：24（對象頭）+8*3=48，不須要padding；

開啓壓縮：16（對象頭）+3*4=28，+padding/4=32，其餘依次類推。

自定義類的數組也是同樣的，好比：

1 2 3 4

staticclassB3 {         inta;         Integer b;     }

new B3[3]佔用的內存大小：

未開啓壓縮：48

開啓壓縮後：32

複合對象

計算複合對象佔用內存的大小其實就是運用上面幾條規則，只是麻煩點。

1）對象自己的大小

直接計算當前對象佔用空間大小，包括當前類及超類的基本類型實例字段大小、引用類型實例字段引用大小、實例基本類型數組總佔用空間、實例引用類型數組引用自己佔用空間大小; 可是不包括超類繼承下來的和當前類聲明的實例引用字段的對象自己的大小、實例引用數組引用的對象自己的大小。

1 2 3 4 5 6 7 8 9 10 11 12 13 14

staticclassB {         inta;         intb;     } staticclassC {         intba;         B[] as =newB[3];           C() {             for(inti =0; i < as.length; i++) {                 as[i] =newB();             }         }     }

未開啓壓縮：16（對象頭）+4（ba）+8（as引用的大小）+padding/4=32

開啓壓縮：12+4+4+padding/4=24

2)當前對象佔用的空間總大小

遞歸計算當前對象佔用空間總大小，包括當前類和超類的實例字段大小以及實例字段引用對象大小。

遞歸計算複合對象佔用的內存的時候須要注意的是：對齊填充是以每一個對象爲單位進行的，看下面這個圖就很容易明白。

如今咱們來手動計算下C對象佔用的所有內存是多少，主要是三部分構成：C對象自己的大小+數組對象的大小+B對象的大小。

未開啓壓縮：

(16 + 4 + 8+4(padding)) + (24+ 8*3) +(16+8)*3 = 152bytes

開啓壓縮：

(12 + 4 + 4 +4(padding)) + (16 + 4*3 +4(數組對象padding)) + (12+8+4（B對象padding）)*3= 128bytes