詳細介紹Java中的堆和棧

標籤：

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

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

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

棧有一個很重要的特殊性，就是存在棧中的資料可以共用。假定我們同時定義：

1. int a = 3;  
2. 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是一個特殊的封裝類資料。可以用：

1. String str = new String("abc");  
2. String str = "abc"; 

兩種的形式來建立，第一種是用new()來建立對象的，它會在寄存於堆中。每調用一次就會建立一個新的對象。

而第二種是先在棧中建立一個對String類的對象引用變數str，然後尋找棧中有沒有寄存"abc"，如果沒有，則將"abc"寄存進棧，並 令str指向”abc”，如果已經有”abc” 則直接令str指向“abc”。

比擬類外面的數值能否相等時，用equals()辦法;當測試兩個封裝類的引用能否指向同一個對象時，用==，下面用例子說明下面的理論。

1. String　str1　=　"abc";  
2. String　str2　=　"abc";  
3. System.out.println(str1==str2);　//true  

可以看出str1和str2是指向同一個對象的。

1. String　str1　=new　String　("abc");  
2. String　str2　=new　String　 ("abc");  
3. System.out.println(str1==str2);　//　false 

用new的方式是產生不 同的對象。每一次產生一個。

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

另一方面, 要注意: 我們在運用諸如String str = "abc";的格式定義類時，總是想當然地以為，建立了String類的對象str。擔心陷阱!對象能夠並沒有被建立!而能夠只是指向一個先前已經建立的 對象。只有經過new()辦法才幹保證每次都建立一個新的對象。

由於String類的immutable性質，當String變數需要經常變換其值時，應該思索運用StringBuffer類，以進步程式效 率。

申請後零碎的照應

棧：只要棧的剩餘空間大於所申請空間，零碎將為程式提供記憶體，否則將報異常提示棧溢出。

堆： 首先應該知道操作零碎有一個記載空閑記憶體位址的鏈表，當零碎收到程式的申請時，會遍曆該鏈表，尋覓第一個空間大於所申請空間的堆結點，然後將該結點從空閑 結點鏈表中刪除，並將該結點的空間分配給程式，另外，對於大多數零碎，會在這塊記憶體空間中的首地址處記載本次分配的大小，這樣，代碼中的delete語句 才幹正確的釋放本記憶體空間。另外，由於找到的堆結點的大小不一定正好等於申請的大小，零碎會自動的將多餘的那部分重新放入空閑鏈表中。

申請大小的限制

棧：在Windows下,棧是向低地址擴充的資料構造，是一塊連續的記憶體的地區。這句話的意思是棧頂的地址和棧的最大容量是零碎預先規定好的， 在WINDOWS下，棧的大小是2M(也能夠是1M，它是一個編譯時間就確定的常數)，如果申請的空間超越棧的剩餘空間時，將提示overflow。因此， 能從棧取得的空間較小。

堆：堆是向高地址擴充的資料構造，是不連續的記憶體地區。這是由於零碎是用鏈表來儲存的空閑記憶體位址的，自然是不連續的，而鏈表的遍曆方向是由低 地址向高地址。堆的大小受限於電腦零碎中有效虛擬記憶體。由此可見，堆取得的空間比擬靈敏，也比擬大。

申請效率的比擬：

棧由零碎自動分配，速度較快。但程式員是無法控制的。

堆是由new分配的記憶體，普通速度比擬慢，而且容易發生記憶體片段,不過用起來最方便.

另外，在WINDOWS下，最好的方式是用VirtualAlloc分配記憶體，他不是在堆，也不是在棧是直接在進程的地址空間中保管一快記憶體， 雖然用起來最不方便。但是速度快，也最靈敏。

堆和棧中的儲存內容

棧：在函數調用時，第一個進棧的是主函數中後的下一條指令(函數調用語句的下一條可執行語句)的地址，然後是函數的各個參數，在大多數的C編譯 器中，參數是由右往左入棧的，然後是函數中的局部變數。注意靜態變數是不入棧的。

當本次函數調用完畢後，局部變數先出棧，然後是參數，最後棧頂指標指向最末尾存的地址，也就是主函數中的下一條指令，程式由該點繼續運轉。

堆：普通是在堆的頭部用一個位元組寄存堆的大小。堆中的詳細內容有程式員布置。

存取效率的比擬

1. char s1 = "aaaaaaaaaaaaaaa";  
2. char *s2 = "bbbbbbbbbbbbbbbbb"; 

aaaaaaaaaaa是在運轉時辰賦值的;

而bbbbbbbbbbb是在編譯時間就確定的;

但是，在以後的存取中，在棧上的數組比指標所指向的字串(例如堆)快。

比如：

1. void　main()  
2. {  
3. char　a　=　1;  
4. char　c[]　=　 "1234567890";  
5. char　*p　="1234567890";  
6. a　=　c[1];  
7. a　=　 p[1];  
8. return;  
9. } 

對應的彙編代碼

1. 10:　a　=　c[1];  
2. 00401067　8A　4D　F1　mov　cl,byte　ptr　[ebp-0Fh]  
3. 0040106A　88　4D　FC　mov　byte　ptr　[ebp-4],cl  
4. 11:　a　=　p[1];  
5. 0040106D　8B　55　EC　mov　edx,dword　ptr　[ebp-14h]  
6. 00401070　8A　42　01　 mov　al,byte　ptr　[edx+1]  
7. 00401073　88　45　FC　mov　byte　ptr　[ebp-4],al 

第一種在讀取時直接就把字串中的元素讀到寄存器cl中，而第二種則要先把指標值讀到edx中，在根據

edx讀取字元，顯然慢了。

小結：

堆和棧的區別可以用如下的比喻來看出：

運用棧就象我們去飯館裡吃飯，只管點菜(收回申請)、付錢、和吃(運用)，吃飽了就走，不用理會切菜、洗菜等預備工作和洗碗、刷鍋等掃尾工作， 他的益處是快捷，但是自由度小。

詳細介紹Java中的堆和棧