Java中堆(heap)和棧(stack)的區別

　　簡單的說： Java把內存劃分紅兩種：一種是棧內存，一種是堆內存。

　　在函數中定義的一些基本類型的變量和對象的引用變量都在函數的棧內存中分配。 當在一段代碼塊定義一個變量時，Java就在棧中爲這個變量分配內存空間，當超過變量的做用域後，Java會自動釋放掉爲該變量所分配的內存空間，該內存空間能夠當即被另做他用。

     堆內存用來存放由new建立的對象和數組。

     在堆中分配的內存，由Java虛擬機的自動垃圾回收器來管理。

　　1. 棧(stack)與堆(heap)都是Java用來在Ram中存放數據的地方。與C++不一樣，Java自動管理棧和堆，程序員不能直接地設置棧或堆。

　　2. 棧的優點是，存取速度比堆要快，僅次於直接位於CPU中的寄存器。但缺點是，存在棧中的數據大小與生存期必須是肯定的，缺少靈活性。另外，棧數據能夠共享，詳見第3點。堆的優點是能夠動態地分配內存大小，生存期也沒必要事先告訴編譯器，Java的垃圾收集器會自動收走這些再也不使用的數據。但缺點是，因爲要在運行時動態分配內存，存取速度較慢。

　　3. Java中的數據類型有兩種。 一種是基本類型(primitive types)， 共有8種，即int， short， long， byte， float， double， boolean， char(注意，並無string的基本類型)。這種類型的定義是經過諸如int a = 3; long b = 255L;的形式來定義的，稱爲自動變量。值得注意的是，自動變量存的是字面值，不是類的實例，即不是類的引用，這裏並無類的存在。如int a = 3; 這裏的a是一個指向int類型的引用，指向3這個字面值。這些字面值的數據，因爲大小可知，生存期可知(這些字面值固定定義在某個程序塊裏面，程序塊退出後，字段值就消失了)，出於追求速度的緣由，就存在於棧中。

　　另外，棧有一個很重要的特殊性，就是存在棧中的數據能夠共享。假設咱們同時定義

 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與 b的值後，再令a=4；那麼，b不會等於4，仍是等於3。在編譯器內部，遇到a=4；時，它就會從新搜索棧中是否有4的字面值，若是沒有，從新開闢地址存放4的值；若是已經有了，則直接將a指向這個地址。所以a值的改變不會影響到b的值。

　　另外一種是包裝類數據，如Integer， String， Double等將相應的基本數據類型包裝起來的類。這些類數據所有存在於堆中，Java用new()語句來顯式地告訴編譯器，在運行時才根據須要動態建立，所以比較靈活，但缺點是要佔用更多的時間。

　　4. String是一個特殊的包裝類數據。便可以用String str = new String("abc");的形式來建立，也能夠用String str = "abc"；的形式來建立(做爲對比，在JDK 5.0以前，你從未見過Integer i = 3;的表達式，由於類與字面值是不能通用的，除了String。而在JDK 5.0中，這種表達式是能夠的！由於編譯器在後臺進行Integer i = new Integer(3)的轉換)。前者是規範的類的建立過程，即在Java中，一切都是對象，而對象是類的實例，所有經過new()的形式來建立。Java 中的有些類，如DateFormat類，能夠經過該類的getInstance()方法來返回一個新建立的類，彷佛違反了此原則。其實否則。該類運用了單例模式來返回類的實例，只不過這個實例是在該類內部經過new()來建立的，而getInstance()向外部隱藏了此細節。那爲何在String str = "abc"；中，並無經過new()來建立實例，是否是違反了上述原則？其實沒有。

　　5. 關於String str = "abc"的內部工做。Java內部將此語句轉化爲如下幾個步驟：

• 先定義一個名爲str的對String類的對象引用變量：String str；
• 在棧中查找有沒有存放值爲"abc"的地址，若是沒有，則開闢一個存放字面值爲"abc"的地址，接着建立一個新的String類的對象o，並將o 的字符串值指向這個地址，並且在棧中這個地址旁邊記下這個引用的對象o。若是已經有了值爲"abc"的地址，則查找對象o，並返回o的地址。
• 將str指向對象o的地址。 值得注意的是，通常String類中字符串值都是直接存值的。但像String str = "abc"；這種場合下，其字符串值倒是保存了一個指向存在棧中數據的引用！ 爲了更好地說明這個問題，咱們能夠經過如下的幾個代碼進行驗證。

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

　　注意，咱們這裏並不用str1.equals(str2)；的方式，由於這將比較兩個字符串的值是否相等。==號，根據JDK的說明，只有在兩個引用都指向了同一個對象時才返回真值。而咱們在這裏要看的是，str1與str2是否都指向了同一個對象。 結果說明，JVM建立了兩個引用str1和str2，但只建立了一個對象，並且兩個引用都指向了這個對象。 咱們再來更進一步，將以上代碼改爲：

String str1 = "abc";
String str2 = "abc";
str1 = "bcd";
System.out.println(str1 + "，" + str2); //bcd， abc
System.out.println(str1==str2); //false

　　這就是說，賦值的變化致使了類對象引用的變化，str1指向了另一個新對象！而str2仍舊指向原來的對象。上例中，當咱們將str1的值改成"bcd"時，JVM發如今棧中沒有存 放該值的地址，便開闢了這個地址，並建立了一個新的對象，其字符串的值指向這個地址。 事實上，String類被設計成爲不可改變(immutable)的類。若是你要改變其值，能夠，但JVM在運行時根據新值悄悄建立了一個新對象，而後將這個對象的地址返回給原來類的引用。這個建立過程雖然說是徹底自動進行的，但它畢竟佔用了更多的時間。在對時間要求比較敏感的環境中，會帶有必定的不良影響。 再修改原來代碼：

String str1 = "abc";
String str2 = "abc";
str1 = "bcd";
String str3 = str1;
System.out.println(str3); //bcd
String str4 = "bcd";
System.out.println(str1 == str4); //true

　　str3 這個對象的引用直接指向str1所指向的對象(注意，str3並無建立新對象)。當str1改完其值後，再建立一個String的引用str4，並指向因str1修改值而建立的新的對象。能夠發現，這回str4也沒有建立新的對象，從而再次實現棧中數據的共享。 咱們再接着看如下的代碼。

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

 

　　建立了兩個引用。建立了兩個對象。兩個引用分別指向不一樣的兩個對象。

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

　　建立了兩個引用。建立了兩個對象。兩個引用分別指向不一樣的兩個對象。

　　以上兩段代碼說明，只要是用new()來新建對象的，都會在堆中建立，並且其字符串是單獨存值的，即便與棧中的數據相同，也不會與棧中的數據共享。

　　6. 數據類型包裝類的值不可修改。不只僅是String類的值不可修改，全部的數據類型 包裝類都不能更改其內部的值。

　　7. 結論與建議：

　　(1) 咱們在使用諸如String str = "abc"；的格式定義類時，老是想固然地認爲，咱們建立了String類的對象str。擔憂陷阱！對象可能並無被建立！惟一能夠確定的是，指向 String類的引用被建立了。至於這個引用究竟是否指向了一個新的對象，必須根據上下文來考慮，除非你經過new()方法來顯要地建立一個新的對象。所以，更爲準確的說法是，咱們建立了一個指向String類的對象的引用變量str，這個對象引用變量指向了某個值爲"abc"的String類。清醒地認識到這一點對排除程序中難以發現的bug是頗有幫助的。

　　(2) 使用String str = "abc"；的方式，能夠在必定程度上提升程序的運行速度，由於JVM會自動根據棧中數據的實際狀況來決定是否有必要建立新對象。而對於String str = new String("abc")；的代碼，則一律在堆中建立新對象，而無論其字符串值是否相等，是否有必要建立新對象，從而加劇了程序的負擔。這個思想應該是享元模式的思想，但JDK的內部在這裏實現是否應用了這個模式，不得而知。

　　(3) 當比較包裝類裏面的數值是否相等時，用equals()方法；當測試兩個包裝類的引用是否指向同一個對象時，用==。

　　(4) 因爲String類的immutable性質，當String變量須要常常變換其值時，應該考慮使用StringBuffer類，以提升程序效率。

java中內存分配策略及堆和棧的比較

內存分配策略

　　按照編譯原理的觀點，程序運行時的內存分配有三種策略，分別是靜態的，棧式的，和堆式的。

　　靜態存儲分配是指在編譯時就能肯定每一個數據目標在運行時刻的存儲空間需求，於是在 編譯時就能夠給他們分配固定的內存空間。這種分配策略要求程序代碼中不容許有可變數據結構(好比可變數組)的存在，也不容許有嵌套或者遞歸的結構出現，由於它們都會致使編譯程序沒法計算準確的存儲空間需求。

　　棧式存儲分配也可稱爲動態存儲分配，是由一個相似於堆棧的運行棧來實現的。和靜態存儲分配相反，在棧式存儲方案中，程序對數據區的需求在編譯時是徹底未知的，只有到運行的時候纔可以知道，可是規定在運行中進入一個程序模塊時，必須知道該程序模塊所需的數據區大小纔可以爲其分配內存.和咱們在數據結構所熟知的棧同樣，棧式存儲分配按照先進後出的原則進行分配。

　　靜態存儲分配要求在編譯時能知道全部變量的存儲要求，棧式存儲分配要求在過程的入口處必須知道全部的存儲要求，而堆式存儲分配則專門負責在編譯時或運行時模塊入口處都沒法肯定存儲要求的數據結構的內存分配，好比可變長度串和對象實例.堆由大片的可利用塊或空閒塊組成，堆中的內存能夠按照任意順序分配和釋放。

堆和棧的比較

　　上面的定義從編譯原理的教材中總結而來，除靜態存儲分配以外，都顯得很呆板和難以理解，下面撇開靜態存儲分配，集中比較堆和棧：

　　從堆和棧的功能和做用來通俗的比較，堆主要用來存放對象的，棧主要是用來執行程序的。而這種不一樣又主要是因爲堆和棧的特色決定的：

　　在編程中，例如C/C++中，全部的方法調用都是經過棧來進行的，全部的局部變量，形式參數都是從棧中分配內存空間的。實際上也不是什麼分配，只是從棧頂向上用就行，就好像工廠中的傳送帶(conveyor belt)同樣，Stack Pointer會自動指引你到放東西的位置，你所要作的只是把東西放下來就行.退出函數的時候，修改棧指針就能夠把棧中的內容銷燬.這樣的模式速度最快，固然要用來運行程序了.須要注意的是，在分配的時候，好比爲一個即將要調用的程序模塊分配數據區時，應事先知道這個數據區的大小，也就說是雖然分配是在程序運行時進行的，可是分配的大小多少是肯定的，不變的，而這個"大小多少"是在編譯時肯定的，不是在運行時.

　　堆是應用程序在運行的時候請求操做系統分配給本身內存，因爲從操做系統管理的內存分配，因此在分配和銷燬時都要佔用時間，所以用堆的效率很是低。可是堆的優勢在於，編譯器沒必要知道要從堆裏分配多少存儲空間，也沒必要知道存儲的數據要在堆裏停留多長的時間，所以，用堆保存數據時會獲得更大的靈活性。事實上，面向對象的多態性，堆內存分配是必不可少的，由於多態變量所需的存儲空間只有在運行時建立了對象以後才能肯定.在C++中，要求建立一個對象時，只需用 new命令編制相關的代碼便可。執行這些代碼時，會在堆裏自動進行數據的保存。固然，爲達到這種靈活性，必然會付出必定的代價：在堆裏分配存儲空間時會花掉更長的時間！這也正是致使咱們剛纔所說的效率低的緣由。

JVM中的堆和棧

　　JVM是基於堆棧的虛擬機。JVM爲每一個新建立的線程都分配一個堆棧。也就是說，對於一個Java程序來講，它的運行就是經過對堆棧的操做來完成的。堆棧以幀爲單位保存線程的狀態。JVM對堆棧只進行兩種操做：以幀爲單位的壓棧和出棧操做。

　　咱們知道，某個線程正在執行的方法稱爲此線程的當前方法。咱們可能不知道，當前方法使用的幀稱爲當前幀。當線程激活一個Java方法，JVM就會在線程的 Java堆棧裏新壓入一個幀。這個幀天然成爲了當前幀。在此方法執行期間，這個幀將用來保存參數，局部變量，中間計算過程和其餘數據。這個幀在這裏和編譯原理中的活動紀錄的概念是差很少的。從Java的這種分配機制來看，堆棧又能夠這樣理解：堆棧(Stack)是操做系統在創建某個進程時或者線程(在支持多線程的操做系統中是線程)爲這個線程創建的存儲區域，該區域具備先進後出的特性。 每個Java應用都惟一對應一個JVM實例，每個實例惟一對應一個堆。應用程序在運行中所建立的全部類實例或數組都放在這個堆中，並由應用全部的線程 共享.跟C/C++不一樣，Java中分配堆內存是自動初始化的。Java中全部對象的存儲空間都是在堆中分配的，可是這個對象的引用倒是在堆棧中分配，也就是說在創建一個對象時從兩個地方都分配內存，在堆中分配的內存實際創建這個對象，而在堆棧中分配的內存只是一個指向這個堆對象的指針(引用)而已。

GC的思考

　　Java爲何慢？JVM的存在固然是一個緣由，但有人說，在Java中，除了簡單類型(int，char等)的數據結構，其它都是在堆中分配內存(因此說Java的一切都是對象)，這也 是程序慢的緣由之一。

　　個人想法是(應該說表明TIJ的觀點)，若是沒有Garbage Collector(GC)，上面的說法就是成立的。堆不像棧是連續的空間，沒有辦法期望堆自己的內存分配可以象堆棧同樣擁有傳送帶般的速度，由於，誰會 爲你整理龐大的堆空間，讓你幾乎沒有延遲的從堆中獲取新的空間呢？

　　這個時候，GC站出來解決問題。咱們都知道GC用來清除內存垃圾，爲堆騰出空間供程序使用，但GC同時也擔負了另一個重要的任務，就是要讓Java中堆的內存分配和其餘語言中堆棧的內存分配同樣快，由於速度的問題幾乎是衆口一詞的對Java的詬病。要達到這樣的目的，就必須使堆的分配也可以作到象傳送帶同樣，不用本身操心去找空閒空間.這樣，GC除了負責清除Garbage外，還要負責整理堆中的對象，把它們轉移到一個遠離Garbage的純淨空間中無間隔的排列起來，就象堆棧中同樣緊湊，這樣Heap Pointer就能夠方便的指向傳送帶的起始位置，或者說一個未使用的空間，爲下一個須要分配內存的對象"指引方向".所以能夠這樣說，垃圾收集影響了對象的建立速度，聽起來很怪，對不對?

　　那GC怎樣在堆中找到全部存活的對象呢？前面說了，在創建一個對象時，在堆中分配實際創建這個對象的內存，而在堆棧中分配一個指向這個堆對象的指針(引 用)，那麼只要在堆棧(也有可能在靜態存儲區)找到這個引用，就能夠跟蹤到全部存活的對象.找到以後，GC將它們從一個堆的塊中移到另一個堆的塊中，並 將它們一個挨一個的排列起來，就象咱們上面說的那樣，模擬出了一個棧的結構，但又不是先進後出的分配，而是能夠任意分配的，在速度能夠保證的狀況下。

　　可是，列寧同志說了，人的優勢每每也是人的缺點，人的缺點每每也是人的優勢(再暈~~).GC()的運行要佔用一個線程，這自己就是一個下降程序運行性能 的缺陷，更況且這個線程還要在堆中把內存翻來覆去的折騰.不只如此，如上面所說，堆中存活的對象被搬移了位置，那麼全部對這些對象的引用都要從新賦值.這 些開銷都會致使性能的下降。

　　基礎數據類型直接在棧空間分配，方法的形式參數，直接在棧空間分配，當方法調用完成後從棧空間回收。引用數據類型，須要用new來建立，既在棧空間 分配一個地址空間，又在堆空間分配對象的類變量 。方法的引用參數，在棧空間分配一個地址空間，並指向堆空間的對象區，當方法調用完成後從棧空間回收。局部變量new出來時，在棧空間和堆空間中分配空 間，當局部變量生命週期結束後，棧空間馬上被回收，堆空間區域等待GC回收。方法調用時傳入的literal參數，先在棧空間分配，在方法調用完成後從棧 空間分配。字 符串常量在DATA區域分配 ， this在堆空間分配。數組既在棧空間分配數組名稱 ， 又在堆空間分配數組實際的大小！

 

原文參考【Java知音網】