轉貼：java記憶體的思考與總結

1. java中堆與棧
在Java程式運行時，有6個地方可以用於儲存資料：
(1) 寄存器。最快的儲存地區，位於處理器內部,數量十分有限，它是根據需要由編譯器分配。我們對此沒有直接的控制權.

(2) 棧(stack)。駐留於常規RAM（隨機訪問儲存空間）地區，這是一種特別快、特別有效資料儲存方式，僅次於寄存器。建立程式時，Java編譯器必須準確地知道堆棧內儲存的所有資料的“長度”以及“存在時間”。這失去了一定的靈活性，因此物件控點是存放在棧中，但Java對象並不放到其中。

(3) 堆(heap)。儲存了Java對象。和棧不同，它最迷人的地方在於編譯器不必知道要從堆裡分配多少儲存空間，也不必知道儲存的資料要在堆裡停留多長的時間。因此，用堆儲存資料時會得到更大的靈活性。要求建立一個對象時，只需用new命令編製相關的代碼即可。執行這些代碼時，會在堆裡自動進行資料的儲存。當然，為達到這種靈活性，必然會付出一定的代價：在堆裡分配儲存空間時會花掉更長的時間！

(4) 靜態儲存。這兒的“靜態”（Static）是指“位於固定位置”（儘管也在RAM裡）。程式運行期間，靜態儲存的資料將隨時等候調用。可用static關鍵字指出一個對象的特定元素是靜態。但Java對象本身永遠都不會置入靜態儲存空間。

(5) 常數儲存。常數值通常直接置於程式碼內部。這樣做是安全的，因為它們永遠都不會改變。有的常數需要嚴格地保護，所以可考慮將它們置入唯讀記憶體（ROM）。

(6) 非RAM儲存。資料完全獨立於一個程式之外，則程式不運行時仍可存在，並在程式的控制範圍之外。

2．堆和棧的區別

棧與堆都是Java用來在Ram中存放資料的地方。與C++不同，Java自動管理棧和堆，程式員不能直接地設定棧或堆。

Java的堆是一個運行時資料區,類的(對象從中分配空間。這些對象通過new、newarray、anewarray和multianewarray等指令建立，它們不需要程式碼來顯式的釋放。堆是由記憶體回收來負責的，堆的優勢是可以動態地分配記憶體大小，生存期也不必事先告訴編譯器，因為它是在運行時動態分配記憶體的，Java的垃圾收集器會自動收走這些不再使用的資料。但缺點是，由於要在運行時動態分配記憶體，存取速度較慢。

棧的優勢是，存取速度比堆要快，僅次於寄存器，棧資料可以共用。但缺點是，存在棧中的資料大小與生存期必須是確定的，缺乏靈活性。棧中主要存放一些基本類型的變數（,int, short, long, byte, float, double, boolean, char）和物件控點。

棧有一個很重要的特殊性，就是存在棧中的資料可以共用。假設我們同時定義：
int a = 3;
int b = 3；
編譯器先處理int a = 3；首先它會在棧中建立一個變數為a的引用，然後尋找棧中是否有3這個值，如果沒找到，就將3存放進來，然後將a指向3。接著處理int b = 3；在建立完b的引用變數後，因為在棧中已經有3這個值，便將b直接指向3。這樣，就出現了a與b同時均指向3的情況。

這時，如果再令a=4；那麼編譯器會重新搜尋棧中是否有4值，如果沒有，則將4存放進來，並令a指向4；如果已經有了，則直接將a指向這個地址。因此a值的改變不會影響到b的值。

要注意這種資料的共用與兩個對象的引用同時指向一個對象的這種共用是不同的，因為這種情況a的修改並不會影響到b, 它是由編譯器完成的，它有利於節省空間的。而一個對象引用變數修改了這個對象的內部狀態，會影響到另一個對象引用變數。

String是一個特殊的封裝類資料。可以用：
String str = new String("abc");
String str = "abc";
兩種的形式來建立，第一種是用new()來建立對象的，它會在存放於堆中。每調用一次就會建立一個新的對象。
而第二種是先在棧中建立一個對String類的對象引用變數str，然後尋找棧中有沒有存放"abc"，如果沒有，則將"abc"存放進棧，並令str指向”abc”，如果已經有”abc” 則直接令str指向“abc”。

比較類裡面的數值是否相等時，用equals()方法；當測試兩個封裝類的引用是否指向同一個對象時，用==，下面用例子說明上面的理論。
String str1 = "abc";
String str2 = "abc";
System.out.println(str1==str2); //true
可以看出str1和str2是指向同一個對象的。

String str1 =new String ("abc");
String str2 =new String ("abc");
System.out.println(str1==str2); // false
用new的方式是產生不同的對象。每一次產生一個。

因此用第二種方式建立多個”abc”字串,在記憶體中其實只存在一個對象而已. 這種寫法有利與節省記憶體空間. 同時它可以在一定程度上提高程式的運行速度，因為JVM會自動根據棧中資料的實際情況來決定是否有必要建立新對象。而對於String str = new String("abc")；的代碼，則一概在堆中建立新對象，而不管其字串值是否相等，是否有必要建立新對象，從而加重了程式的負擔。

另一方面, 要注意: 我們在使用諸如String str = "abc"；的格式定義類時，總是想當然地認為，建立了String類的對象str。擔心陷阱！對象可能並沒有被建立！而可能只是指向一個先前已經建立的對象。只有通過new()方法才能保證每次都建立一個新的對象。
由於String類的immutable性質，當String變數需要經常變換其值時，應該考慮使用StringBuffer類，以提高程式效率。

參考文獻：
關於Java棧與堆的思考
http://www.duduwolf.com/post/3.asp

第2章 一切都是對象
http://52cg.com/Training/KaiFa/java/200510/31900.html

3．關於java中資料佔用記憶體空間的大小
――測試環境
j2me midp1.0
――測試方法：
使用下面的語句，擷取對象建立前後的記憶體值，它們的差值就為所建立對象佔用的記憶體大小:
1．i = Runtime.getRuntime().freeMemory();
2．control = new Control(Control.HEAD_MOVE, 1, 1);
3．j = Runtime.getRuntime().freeMemory();
4．System.out.println(i-j);
這個方法並不準確，因為JVM會不定時在後台運行一些東西，比如在gc，後台運行東西會佔用一定的記憶體，如果這個背景程式的運行發生在1、3句之間的時候就會造成不準確。

為了儘可能保持正確性，將語句變為如下，先gc，再取記憶體，讓那些由於後台運行而佔用的記憶體釋放出來。
Runtime.getRuntime().gc();
Thread.yield();
i = Runtime.getRuntime().freeMemory();
test t = new test();
Runtime.getRuntime().gc();
Thread.yield();
j = Runtime.getRuntime().freeMemory();
System.out.println(i-j);
但是這種方法還是不一定能夠保證gc會被調用，因此每一個測試得到的資料都是多次測試得出相同的那個資料，取當堆大小穩定以後顯示的資料，追求盡量準確。

（1） i = Runtime.getRuntime().freeMemory();
int t = 0;
char a ='a';
long l =23410389;
j = Runtime.getRuntime().freeMemory();
System.out.println(i-j); // 0
【結論】因為基礎資料型別 (Elementary Data Type)存放在棧中，並不佔用堆的記憶體，可見freeMemory返回的數值是堆中的記憶體，因此值為0。

（2）
i = Runtime.getRuntime().freeMemory();
String s2="1234567";
j = Runtime.getRuntime().freeMemory();
System.out.println(i-j); // 0
―――――――――――――――――――――――――――――――
i = Runtime.getRuntime().freeMemory();
String s2=new String("1234567");
j = Runtime.getRuntime().freeMemory();
System.out.println(i-j); // 56

【結論】以String s2="1234567"方式建立的字串是存放在棧中，它不佔用堆空間；而用String s2=new String("1234567");方式建立的字串是存放在堆中，它佔用了56byte的堆空間。

（3）
Runtime.getRuntime().gc();
Thread.yield();
i = Runtime.getRuntime().freeMemory();
test t = new test(); //test為一個空的Class
Runtime.getRuntime().gc();
Thread.yield();
j = Runtime.getRuntime().freeMemory();
System.out.println(i-j); // 12

――――――――――――――――――――――――――――――――
Runtime.getRuntime().gc();
Thread.yield();
i = Runtime.getRuntime().freeMemory();
Contorl c = new Control(Control.HEAD_MOVE, 1, 1);
Runtime.getRuntime().gc();
Thread.yield();
j = Runtime.getRuntime().freeMemory();
System.out.println(i-j); //112

【結論1】：一個空的對象需要佔用12byte的堆空間，將其理解為對象頭。
【結論2】：一個zhanguo/Control的一個“HEAD_MOVE”對象佔用112byte堆空間。

為何是112byte？
Control中有25個非static的基礎資料型別 (Elementary Data Type)和引用變數，而int，short，byte等基礎資料型別 (Elementary Data Type)和引用變數佔用的記憶體大小都是4byte（詳見4），因此大小為：
25*4 + 12 (對象頭)＝＝112

（4）在上面的Class test中加入： private int a = 0;
得出結果：16byte ，
由（3）可以知空object佔12byte，所以一個int佔用4byte的空間。
將int改為其他基礎資料型別 (Elementary Data Type)，用同樣方法進行測試，得出如下結論：
【結論1】：float, boolean，byte, short, int, char佔用4個byte的空間，
long，double佔用8byte空間 (midp1.0不支援float和double)
引用變數，比如 Control c = null, 佔用4byte空間。

【結論2】：在java中類型決定行為，而不是大小；用byte起到限制資料的作用，但是並不能節約記憶體，在記憶體中byte和int一樣是佔用4byte的空間。

【結論3】：雖然a為基本的資料類型，但是它是對象t的一個屬性，是在運行時才動態建立的，因此它也是存放在堆中，佔用4byte的堆空間。

（5）在Class test中加入下面語句：並去掉（4）中加入的變數 int a。
private final static int j = 1;
private final static int k = 4;
private static void testFunction(){
}
得出結果：12
【結論1】一個object的佔用堆空間的多少只與類中的非static的基礎資料型別 (Elementary Data Type)和引用變數有關，而與static的變數和function的多少並沒有關係。Static是存放在“靜態儲存空間”，不佔用堆空間。

【結論2】對於需要產生多個object的類，比如control等，類中的成員變數盡量用static，因為object中的非staitc變數在堆中需要佔用一定的空間，當object數量比較多時，佔用的堆空間會增大很多。從而容易出現記憶體不足（主要是堆空間不足）造成“應用程式錯誤”的情況。

（6）
i = Runtime.getRuntime().freeMemory();
Strin s=new String("");
j = Runtime.getRuntime().freeMemory();
System.out.println(i-j); //40
【結論】一個空的String就要佔用40位元組的堆空間，理解為String頭資訊，在代碼中要避免反覆得new一個相同的string，而是應該利用上面（2）中所講的那種方式：
String s2="1234567"來產生String。

（7）
Runtime.getRuntime().gc();
Thread.yield();
i = Runtime.getRuntime().freeMemory();
int a[][] = new int[0][0];
Runtime.getRuntime().gc();
Thread.yield();
j = Runtime.getRuntime().freeMemory();
System.out.println(i-j); //16
----------------------------------------------------------------------------------
int a[][] = new int[1][0]; //36
int a[][] = new int[2][0]; //56
int a[][] = new int[3][0]; //76
int a[][] = new int[200][0]; //4016
int a[][] = new int[200][1]; //4816 ，因為比上面多了200個int，所以多了800

【結論1】每一個嵌套的int[dim2]都是一個對象，一個int佔用4byte空間，每一個對象都有一個16位元組的數組對象頭。
【結論2】二維數組的數組頭的記憶體消耗很大，對於對記憶體較小的手機，比如nokia舊40系列，最好將二維數組改為用一維數組。

參考文章：
Discover how much memory an object consumes
http://www.mywelt.net/?q=node/577

你知道資料大小嗎？－不要花太多的功夫來隱藏類的成員
http://istudy.com.ru/Article/Software/Java/20051025/54,81897,0.html

TODO：
1． 關於類，變數，函數等與jar大小的關係，考慮混淆器的作用，對於混淆器可以做到的就不必在程式中去改變。
2． 關於j2me程式與記憶體的關係進一步深化，比如線程，gc等等。

？？？
1．Java程式編譯後編程*.class檔案，那麼在運行時這些檔案是一次性載入進記憶體的？如此程式碼很長的話，光是存放這些代碼就要消耗大量的記憶體？它們是存放在記憶體的什麼地方？上面提到的幾個地方明顯都不是存放代碼的地方。