| 導購 | 订阅 | 在线投稿
分享
 
 
 

Java綜合:討論關于Java占用內存的研究

來源:互聯網  2008-06-01 03:23:08  評論

最近對程序占用內存方面做了一些優化,取得了不錯的效果,總結了一些經驗。

簡要說一下,相信會對大家寫出優質的程序有所幫助。

下面的論述針對32位系統,對64位系統不適用,後敘經常你寫了一個程序,一測試,功能沒問題,一看內存占用也不多,就不去考慮其它的東西了。但可能程序使用了一個什麽數據結構,會當數據規模變大時,內存占用激增。

基本&&關鍵的問題是,Java裏各種東東占多少內存?????????

對于primitive類型,有8個

byte short int long float double char boolean 它們的長度分別是

1 2 4 8 4 8 2 1

這個不羅嗦了,舉例來說

long[] data=new long[1000];

占用內存 8*1000 bytes

此外,data本身是一個Object,也占用內存若幹,後敘,當然它針對 8*1000來說,忽略不計

再說Object的占用,在說這個之前,先說說引用,一慣的說法是

Java裏沒有指針了,只有引用,引用是安全的

這個說法沒錯,但是從機理上來說,引用就是指針,只是jvm對指針的使用檢查和限制很多,這個引用/指針變得很安全

直接來結論:一個引用占4byte ,在32位系統上

Object obj=null; //4byte

Object[] objs=new Object[1000]; //至少4*1000byte

你看我定義了一個 obj,還是null,就占4byte

定義了一個 objs,1000個元素,但都是null啊,就都每個占4byte

是的!!!!!

雖然obj==null,但它已經是 一個引用,或者說一個指針了

指針也要占地方啊!!!!啊!!!!啊!!!!

接下來,直接給另一個結論: Object占8byte,注意,純Object

Object obj=new Object(); //多少????

8byte?? 錯!! 12byte,忘了還有一個引用,8byte是Object的內容

記住 Object obj=new Object(); 占12byte

Object[] objs=new Object[1000];

for(int i=0;i<1000;i++) {

objs[i]=new Object();

}

至少占用 12*1000 bytes

推論: Object占12bytes,似乎和上面的結論矛盾??!!

沒有!! 不管Object,沒有被垃圾回收之前,總得被別人引用吧?

總的有指針指它吧? 既然指,那個引用or指針就要占地方啊 4byte

加起來是12byte,反正一個Object至少 12bytes

還是直接給結論,推導的過程我就都包辦了,咱不是髒活累活搶著幹麽!!

一個Integer占 16 bytes

這時您可能會有疑問,Integer=Object+int,就是:

public class Integer {

public int value;

}

Integer應該占 8+4=12 bytes啊

你說的有道理,但是jvm對所有的Object有限制!!

這個限制被我發現了,就是不管什麽Object占的空間,要是8的倍數

12不是8的倍數,只能是16了!!!

推論:Byte也占16bytes!!!!!!!!!!!

問:

Byte[] bytes=new Byte[1000];

占用空間多少?

答: 約爲(至少爲) (16+4)*1000 bytes

好家夥!!!!!!!!

論題:數組空間占用怎麽算?

我這裏直接給結論了,推導這個花了更長的時間:

對于數組來說,數組這個Object有一個length屬性,數組的元素相當于其成員

public class Array {

public int length;

//... 其它成員

}

對于數組,我們不是直接可以取length屬性麽,源于此

public byte[] bytes=new byte[1000];

System.out.println(bytes.length); // 看,有length屬性

上面的bytes換算過來是:

public class Array {

public int length;

public byte byte0;

public byte byte1;

...

public byte byte999;

}

上面的bytes占用的內存是:

4+[8+4 + 1*1000] = 4+ [1012]=4+1016=1020

4是 bytes這個引用,8是Object基占的,4是length屬性占的

1000是1000個成員占的,本來是 1012,但要求是8的倍數,變成 1016了

總共是 1020

再如:

byte[] bytes=new byte[4];

的內存占用是:

4+[8+4+4*1]=4+[16]=20;

byte[] bytes=new byte[3]; 也是 20

對于元素是Object的數組,Object也是當作其成員,(注意只有引用這個數組的空間,這個可以推到普通Class上)

Byte[] bytes=new Byte[1000];

這個 bytes的定義相當于:

public class Array {

public int length;

public Byte byte0;

.....

public Byte byte999;

}

占用空間是:

4+[8+4+4*1000]+16*1000= 4+ 4016 + 16000 = 你自己算吧

推論:千萬不要用 Byte[] 有20倍的差距!!!!!!!

你可能一下子沒明白過來,沒關系多琢磨一下,對于普通的class來說

,內容占用就是基加成員的占用,Object成員只記引用

public class Abc {

public int n;

public byte b;

public Object obj;

}

它的內容占用是: [8+4+1+4]=24

所以 Abc one=new Abc()的占用是 4+24=28

提醒:對于 Abc的成員 obj沒有計,如果要計入的話,循環這個過程就可以了。(琢磨一下)

舉例:

public class Abc {

public byte b;

public Object obj=null;

}

public class Def {

public int n;

public byte b;

public Abc obj=new Abc();

}

問:

Def one=new Def(); //占多少?

答:

4+[8+4+1+4]+[8+1+4]=4+24+16=44

public class Abc {

public byte b;

public Object obj=null;

}

public class Def {

public int n;

public byte b;

public Abc[] objs=new Abc[100];

{

for(int i=0;i<10;i++) {

objs[i]=new Abc();

}

}

}

問:

Def one=new Def(); //占多少?

答:

kao,一下我也算不出來,不過我寫了程序,可以算出來,你給它一個Object,它就能遞歸的算出總共占了多少內存,這個程序不複雜,你也可以寫出來。我等機會合適了再放出。

單獨說一下String,String的結構是:

public class String {

private final char value[];

private final int offset;

private final int count;

private int hash; // Default to 0

}

所以,不考慮那個char[]的占用,一個String最少占用 [8+4+4+4+4]=24bytes

加上引用,共28bytes

所以

String s="";

占用28bytes!!!!! 盡管它的長度爲0

如果精確的算,加上引用一個String的占用是

4+24+[8+4+2*length]

String s=""; 的占用是 28+16= 44

String s="ab" 的占用是 28+16= 44

String s="abc" 的占用是 28+24 = 52

要說的是,String是常用的類,這麽看,String耗內存很多,所以jvm有優化,同樣的內容盡量重用,所以除了28是必須的外,那個char[] 很可能一樣

比方說

String[] s=new String[1000];

for(int i=0;i<1000;i++) {

s[i]=new String("abcdefasdjflksadjflkasdfj");

}

的占用的數量級是 28*1000,那 1000個字符串本身基本上不占內存,只有一份!!!!!!

反正String 至少是 28,最多也可能是28!!!!!!!!

比較占內存的數據結構,這個很重要:

基本上就是 primitive的包裝

實例:

我以前用一個

Hashtable的結構,有100萬個元素

改爲String[]+int[]後,內存占用改觀不少,速度也很快

100萬的String[] 快排一下,也就2秒多,查找用2分,和hash也差不多少。

最近對程序占用內存方面做了一些優化,取得了不錯的效果,總結了一些經驗。 簡要說一下,相信會對大家寫出優質的程序有所幫助。 下面的論述針對32位系統,對64位系統不適用,後敘經常你寫了一個程序,一測試,功能沒問題,一看內存占用也不多,就不去考慮其它的東西了。但可能程序使用了一個什麽數據結構,會當數據規模變大時,內存占用激增。 基本&&關鍵的問題是,Java裏各種東東占多少內存????????? 對于primitive類型,有8個 byte short int long float double char boolean 它們的長度分別是 1 2 4 8 4 8 2 1 這個不羅嗦了,舉例來說 long[] data=new long[1000]; 占用內存 8*1000 bytes 此外,data本身是一個Object,也占用內存若幹,後敘,當然它針對 8*1000來說,忽略不計 再說Object的占用,在說這個之前,先說說引用,一慣的說法是 Java裏沒有指針了,只有引用,引用是安全的 這個說法沒錯,但是從機理上來說,引用就是指針,只是jvm對指針的使用檢查和限制很多,這個引用/指針變得很安全 直接來結論:一個引用占4byte ,在32位系統上 Object obj=null; //4byte Object[] objs=new Object[1000]; //至少4*1000byte 你看我定義了一個 obj,還是null,就占4byte 定義了一個 objs,1000個元素,但都是null啊,就都每個占4byte 是的!!!!! 雖然obj==null,但它已經是 一個引用,或者說一個指針了 指針也要占地方啊!!!!啊!!!!啊!!!! 接下來,直接給另一個結論: Object占8byte,注意,純Object Object obj=new Object(); //多少???? 8byte?? 錯!! 12byte,忘了還有一個引用,8byte是Object的內容 記住 Object obj=new Object(); 占12byte Object[] objs=new Object[1000]; for(int i=0;i<1000;i++) { objs[i]=new Object(); } 至少占用 12*1000 bytes 推論: Object占12bytes,似乎和上面的結論矛盾??!! 沒有!! 不管Object,沒有被垃圾回收之前,總得被別人引用吧? 總的有指針指它吧? 既然指,那個引用or指針就要占地方啊 4byte 加起來是12byte,反正一個Object至少 12bytes 還是直接給結論,推導的過程我就都包辦了,咱不是髒活累活搶著幹麽!! 一個Integer占 16 bytes 這時您可能會有疑問,Integer=Object+int,就是: public class Integer { public int value; } Integer應該占 8+4=12 bytes啊 你說的有道理,但是jvm對所有的Object有限制!! 這個限制被我發現了,就是不管什麽Object占的空間,要是8的倍數 12不是8的倍數,只能是16了!!! 推論:Byte也占16bytes!!!!!!!!!!! 問: Byte[] bytes=new Byte[1000]; 占用空間多少? 答: 約爲(至少爲) (16+4)*1000 bytes 好家夥!!!!!!!! 論題:數組空間占用怎麽算? 我這裏直接給結論了,推導這個花了更長的時間: 對于數組來說,數組這個Object有一個length屬性,數組的元素相當于其成員 public class Array { public int length; //... 其它成員 } 對于數組,我們不是直接可以取length屬性麽,源于此 public byte[] bytes=new byte[1000]; System.out.println(bytes.length); // 看,有length屬性 上面的bytes換算過來是: public class Array { public int length; public byte byte0; public byte byte1; ... public byte byte999; } 上面的bytes占用的內存是: 4+[8+4 + 1*1000] = 4+ [1012]=4+1016=1020 4是 bytes這個引用,8是Object基占的,4是length屬性占的 1000是1000個成員占的,本來是 1012,但要求是8的倍數,變成 1016了 總共是 1020 再如: byte[] bytes=new byte[4]; 的內存占用是: 4+[8+4+4*1]=4+[16]=20; byte[] bytes=new byte[3]; 也是 20 對于元素是Object的數組,Object也是當作其成員,(注意只有引用這個數組的空間,這個可以推到普通Class上) Byte[] bytes=new Byte[1000]; 這個 bytes的定義相當于: public class Array { public int length; public Byte byte0; ..... public Byte byte999; } 占用空間是: 4+[8+4+4*1000]+16*1000= 4+ 4016 + 16000 = 你自己算吧 推論:千萬不要用 Byte[] 有20倍的差距!!!!!!! 你可能一下子沒明白過來,沒關系多琢磨一下,對于普通的class來說 ,內容占用就是基加成員的占用,Object成員只記引用 public class Abc { public int n; public byte b; public Object obj; } 它的內容占用是: [8+4+1+4]=24 所以 Abc one=new Abc()的占用是 4+24=28 提醒:對于 Abc的成員 obj沒有計,如果要計入的話,循環這個過程就可以了。(琢磨一下) 舉例: public class Abc { public byte b; public Object obj=null; } public class Def { public int n; public byte b; public Abc obj=new Abc(); } 問: Def one=new Def(); //占多少? 答: 4+[8+4+1+4]+[8+1+4]=4+24+16=44 public class Abc { public byte b; public Object obj=null; } public class Def { public int n; public byte b; public Abc[] objs=new Abc[100]; { for(int i=0;i<10;i++) { objs[i]=new Abc(); } } } 問: Def one=new Def(); //占多少? 答: kao,一下我也算不出來,不過我寫了程序,可以算出來,你給它一個Object,它就能遞歸的算出總共占了多少內存,這個程序不複雜,你也可以寫出來。我等機會合適了再放出。 單獨說一下String,String的結構是: public class String { private final char value[]; private final int offset; private final int count; private int hash; // Default to 0 } 所以,不考慮那個char[]的占用,一個String最少占用 [8+4+4+4+4]=24bytes 加上引用,共28bytes 所以 String s=""; 占用28bytes!!!!! 盡管它的長度爲0 如果精確的算,加上引用一個String的占用是 4+24+[8+4+2*length] String s=""; 的占用是 28+16= 44 String s="ab" 的占用是 28+16= 44 String s="abc" 的占用是 28+24 = 52 要說的是,String是常用的類,這麽看,String耗內存很多,所以jvm有優化,同樣的內容盡量重用,所以除了28是必須的外,那個char[] 很可能一樣 比方說 String[] s=new String[1000]; for(int i=0;i<1000;i++) { s[i]=new String("abcdefasdjflksadjflkasdfj"); } 的占用的數量級是 28*1000,那 1000個字符串本身基本上不占內存,只有一份!!!!!! 反正String 至少是 28,最多也可能是28!!!!!!!! 比較占內存的數據結構,這個很重要: 基本上就是 primitive的包裝 實例: 我以前用一個 Hashtable的結構,有100萬個元素 改爲String[]+int[]後,內存占用改觀不少,速度也很快 100萬的String[] 快排一下,也就2秒多,查找用2分,和hash也差不多少。
󰈣󰈤
 
 
 
>>返回首頁<<
 
 
 
 
 熱帖排行
 
 
 
靜靜地坐在廢墟上,四周的荒凉一望無際,忽然覺得,淒涼也很美
© 2005- 王朝網路 版權所有