隨筆檔案(496)

轉(zhuǎn)載自：http://java.ccidnet.com/art/3539/20080508/1443759_1.html

最近對程序占用內(nèi)存方面做了一些優(yōu)化，取得了不錯的效果，總結(jié)了一些經(jīng)驗。

簡要說一下，相信會對大家寫出優(yōu)質(zhì)的程序有所幫助。

下面的論述針對32位系統(tǒng)，對64位系統(tǒng)不適用，后敘經(jīng)常你寫了一個程序，一測試，功能沒問題，一看內(nèi)存占用也不多，就不去考慮其它的東西了。但可能程序使用了一個什么數(shù)據(jù)結(jié)構(gòu)，會當(dāng)數(shù)據(jù)規(guī)模變大時，內(nèi)存占用激增。

基本&&關(guān)鍵的問題是，Java里各種東東占多少內(nèi)存？？？？？？？？？

對于primitive類型，有8個

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

1 2 4 8 4 8 2 1

這個不羅嗦了，舉例來說

long[] data=new long[1000];

占用內(nèi)存 8*1000 bytes

此外，data本身是一個Object，也占用內(nèi)存若干，后敘，當(dāng)然它針對 8*1000來說，忽略不計

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

Java里沒有指針了，只有引用，引用是安全的

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

直接來結(jié)論：一個引用占4byte ，在32位系統(tǒng)上

Object obj=null; //4byte

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

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

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

是的?。。。?！

雖然obj==null，但它已經(jīng)是 一個引用，或者說一個指針了

指針也要占地方啊?。。?！?。。。。“。。。?！

接下來，直接給另一個結(jié)論： Object占8byte，注意，純Object

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

8byte？？ 錯??！ 12byte，忘了還有一個引用，8byte是Object的內(nèi)容

記住 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，似乎和上面的結(jié)論矛盾？？?。?/p>

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

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

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

還是直接給結(jié)論，推導(dǎo)的過程我就都包辦了，咱不是臟活累活搶著干么?。?/p>

一個Integer占 16 bytes

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

public class Integer {

public int value;

}

Integer應(yīng)該占 8+4=12 bytes啊

你說的有道理，但是jvm對所有的Object有限制?。?/p>

這個限制被我發(fā)現(xiàn)了，就是不管什么Object占的空間，要是8的倍數(shù)

12不是8的倍數(shù)，只能是16了?。。?/p>

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

問：

Byte[] bytes=new Byte[1000];

占用空間多少？

答： 約為（至少為） (16+4)*1000 bytes

好家伙?。。。。。。?！

論題：數(shù)組空間占用怎么算？

我這里直接給結(jié)論了，推導(dǎo)這個花了更長的時間：

對于數(shù)組來說，數(shù)組這個Object有一個length屬性，數(shù)組的元素相當(dāng)于其成員

public class Array {

public int length;

//... 其它成員

}

對于數(shù)組，我們不是直接可以取length屬性么，源于此

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

System.out.println(bytes.length); // 看，有l(wèi)ength屬性

上面的bytes換算過來是：

public class Array {

public int length;

public byte byte0;

public byte byte1;

...

public byte byte999;

}

上面的bytes占用的內(nèi)存是：

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

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

1000是1000個成員占的，本來是 1012，但要求是8的倍數(shù)，變成 1016了

總共是 1020

再如：

byte[] bytes=new byte[4];

的內(nèi)存占用是:

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

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

對于元素是Object的數(shù)組，Object也是當(dāng)作其成員，（注意只有引用這個數(shù)組的空間，這個可以推到普通Class上）

Byte[] bytes=new Byte[1000];

這個 bytes的定義相當(dāng)于:

public class Array {

public int length;

public Byte byte0;

.....

public Byte byte999;

}

占用空間是：

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

推論：千萬不要用 Byte[] 有20倍的差距?。。。。。?！

你可能一下子沒明白過來，沒關(guān)系多琢磨一下，對于普通的class來說

，內(nèi)容占用就是基加成員的占用，Object成員只記引用

public class Abc {

public int n;

public byte b;

public Object obj;

}

它的內(nèi)容占用是： [8+4+1+4]=24

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

提醒：對于 Abc的成員 obj沒有計，如果要計入的話，循環(huán)這個過程就可以了。（琢磨一下）

舉例：

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，它就能遞歸的算出總共占了多少內(nèi)存，這個程序不復(fù)雜，你也可以寫出來。我等機會合適了再放出。

單獨說一下String，String的結(jié)構(gòu)是：

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耗內(nèi)存很多，所以jvm有優(yōu)化，同樣的內(nèi)容盡量重用，所以除了28是必須的外，那個char[] 很可能一樣

比方說

String[] s=new String[1000];

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

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

}

的占用的數(shù)量級是 28*1000，那 1000個字符串本身基本上不占內(nèi)存，只有一份！?。。。。?/p>

反正String 至少是 28,最多也可能是28！?。。。。。?！

比較占內(nèi)存的數(shù)據(jù)結(jié)構(gòu)，這個很重要：

基本上就是 primitive的包裝

實例：

我以前用一個

Hashtable的結(jié)構(gòu)，有100萬個元素

改為String[]＋int[]后，內(nèi)存占用改觀不少，速度也很快

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