Java設計模式筆試題（10~13題）

10、談談 JVM 的內存結構和內存分配

● Java內存模型：Java虛擬機將其管轄的內存大致分三個邏輯部分：方法區(Method Area)、Java棧和Java堆。

● 方法區是靜態分配的，編譯器將變量綁定在某個存儲位置上，而且這些綁定不會在運行時改變。常數池，源代碼中的命名常量、String常量和static變量保存在方法區。

● Java Stack是一個邏輯概念，特點是后進先出。一個棧的空間可能是連續的，也可能是不連續的。最典型的Stack應用是方法的調用，Java虛擬機每調用一次方法就創建一個方法幀（frame），退出該方法則對應的 方法幀被彈出(pop)。棧中存儲的數據也是運行時確定的。

● Java堆分配(heap allocation)意味著以隨意的順序，在運行時進行存儲空間分配和收回的內存管理模型。堆中存儲的數據常常是大小、數量和生命期在編譯時無法確定的。Java對象的內存總是在heap中分配。

● java內存分配

● 基礎數據類型直接在棧空間分配；

● 方法的形式參數，直接在棧空間分配，當方法調用完成后從棧空間回收；

● 引用數據類型，需要用new來創建，既在棧空間分配一個地址空間，又在堆空間分配對象的類變量；

● 方法的引用參數，在棧空間分配一個地址空間，并指向堆空間的對象區，當方法調用完后從棧空間回收；

● 局部變量new出來時，在棧空間和堆空間中分配空間，當局部變量生命周期結束后，棧空間立刻被回收，堆空間區域等待GC回收；

● 方法調用時傳入的實際參數，先在棧空間分配，在方法調用完成后從棧空間釋放;

● 字符串常量在DATA區域分配，this在堆空間分配；

● 數組既在棧空間分配數組名稱，又在堆空間分配數組實際的大小！

11、Java中引用類型都有哪些？（重要）

● Java中對象的引用分為四種級別，這四種級別由高到低依次為：強引用、軟引用、弱引用和虛引用。

● 強引用（StrongReference）

如果一個對象被人擁有強引用，那么垃圾回收器絕不會回收它。當內存空間不足，Java虛擬機寧愿拋出OutOfMemoryError錯誤，使程序異常終止，也不會靠隨意回收具有強引用的對象來解決內存不足問題。Java的對象是位于heap中的，heap中對象有強可及對象、軟可及對象、弱可及對象、虛可及對象和不可到達對象。應用的強弱順序是強、軟、弱、和虛。對于對象是屬于哪種可及的對象，由他的最強的引用決定。如下代碼：

String abc=new String("abc"); //1
SoftReference<String> softRef=new SoftReference<String>(abc); //2
WeakReference<String> weakRef = new WeakReference<String>(abc); //3
abc=null; //4
softRef.clear();//5

第一行在heap堆中創建內容為“abc”的對象，并建立abc到該對象的強引用，該對象是強可及的。

第二行和第三行分別建立對heap中對象的軟引用和弱引用，此時heap中的abc對象已經有3個引用，顯然此時abc對象仍是強可及的。

第四行之后heap中對象不再是強可及的，變成軟可及的。

第五行執行之后變成弱可及的。

● 軟引用（SoftReference）

如果一個對象只具有軟引用，那么如果內存空間足夠，垃圾回收器就不會回收它，如果內存空間不足了，就會回收這些對象的內存。只要垃圾回收器沒有回收它，該對象就可以被程序使用。軟引用可用來實現內存敏感的高速緩存。軟引用可以和一個引用隊列（ReferenceQueue）聯合使用，如果軟引用所引用的對象被垃圾回收，Java虛擬機就會把這個軟引用加入到與之關聯的引用隊列中。軟引用是主要用于內存敏感的高速緩存。在jvm報告內存不足之前會清除所有的軟引用，這樣以來gc就有可能收集軟可及的對象，可能解決內存吃緊問題，避免內存溢出。什么時候會被收集取決于gc的算法和gc運行時可用內存的大小。當gc決定要收集軟引用時執行以下過程，

以上面的softRef為例：

（1）首先將softRef的referent（abc）設置為null，不再引用heap中的new String("abc")對象。

（2）將heap中的new String("abc")對象設置為可結束的(finalizable)。

（3）當heap中的new String("abc")對象的finalize()方法被運行而且該對象占用的內存被釋放，softRef被添加到它的ReferenceQueue(如果有的話)中。

注意:對ReferenceQueue軟引用和弱引用可以有可無，但是虛引用必須有。

被Soft Reference指到的對象，即使沒有任何Direct Reference，也不會被清除。一直要到JVM內存不足且沒有Direct Reference時才會清除，SoftReference是用來設計object-cache之用的。如此一來SoftReference不但可以把對象cache起來，也不會造成內存不足的錯誤（OutOfMemoryError）。

● 弱引用（WeakReference）

如果一個對象只具有弱引用，那該類就是可有可無的對象，因為只要該對象被gc掃描到了隨時都會把它干掉。弱引用與軟引用的區別在于：只具有弱引用的對象擁有更短暫的生命周期。在垃圾回收器線程掃描它所管轄的內存區域的過程中，一旦發現了只具有弱引用的對象，不管當前內存空間足夠與否，都會回收它的內存。不過，由于垃圾回收器是一個優先級很低的線程，因此不一定會很快發現那些只具有弱引用的對象。弱引用可以和一個引用隊列（ReferenceQueue）聯合使用，如果弱引用所引用的對象被垃圾回收，Java虛擬機就會把這個弱引用加入到與之關聯的引用隊列中。

● 虛引用（PhantomReference）

"虛引用"顧名思義，就是形同虛設，與其他幾種引用都不同，虛引用并不會決定對象的生命周期。如果一個對象僅持有虛引用，那么它就和沒有任何引用一樣，在任何時候都可能被垃圾回收。虛引用主要用來跟蹤對象被垃圾回收的活動。虛引用與軟引用和弱引用的一個區別在于：虛引用必須和引用隊列（ReferenceQueue）聯合使用。當垃圾回收器準備回收一個對象時，如果發現它還有虛引用，就會在回收對象的內存之前，把這個虛引用加入到與之關聯的引用隊列中。程序可以通過判斷引用隊列中是否已經加入了虛引用，來了解被引用的對象是否將要被垃圾回收。程序如果發現某個虛引用已經被加入到引用隊列，那么就可以在所引用的對象的內存被回收之前采取必要的行動。建立虛引用之后通過get方法返回結果始終為null，通過源代碼你會發現，虛引用通向會把引用的對象寫進referent，只是get方法返回結果為null。先看一下和gc交互的過程再說一下他的作用。

（1）不把referent設置為null，直接把heap中的new String("abc")對象設置為可結束的(finalizable)。

（2）與軟引用和弱引用不同，先把PhantomRefrence對象添加到它的ReferenceQueue中.然后在釋放虛可及的對象。

12、heap和stack有什么區別？

● 從以下幾個方面闡述堆（heap）和棧（stack）的區別。

● 申請方式

stack:由系統自動分配。例如，聲明在函數中一個局部變量int b;系統自動在棧中為b開辟空間。

heap:需要程序員自己申請，并指明大小，在c中malloc函數，對于Java需要手動new Object()的形式開辟。

● 申請后系統的響應

stack：只要棧的剩余空間大于所申請空間，系統將為程序提供內存，否則將報異常提示棧溢出。

heap：首先應該知道操作系統有一個記錄空閑內存地址的鏈表，當系統收到程序的申請時，

會遍歷該鏈表，尋找第一個空間大于所申請空間的堆結點，然后將該結點從空閑結點鏈表中刪除，并將該結點的空間分配給程序。另外，由于找到的堆結點的大小不一定正好等于申請的大小，系統會自動的將多余的那部分重新放入空閑鏈表中。

● 申請大小的限制

stack：棧是向低地址擴展的數據結構，是一塊連續的內存的區域。這句話的意思是棧頂的地址和棧的最大容量是系統預先規定好的，在WINDOWS下，棧的大小是2M（也有的說是1M，總之是一個編譯時就確定的常數），如果申請的空間超過棧的剩余空間時，將提示overflow。因此，能從棧獲得的空間較小。

heap：堆是向高地址擴展的數據結構，是不連續的內存區域。這是由于系統是用鏈表來存儲的空閑內存地址的，自然是不連續的，而鏈表的遍歷方向是由低地址向高地址。堆的大小受限于計算機系統中有效的虛擬內存。由此可見，堆獲得的空間比較靈活，也比較大。

● 申請效率的比較：

stack：由系統自動分配，速度較快。但程序員是無法控制的。

heap：由new分配的內存，一般速度比較慢，而且容易產生內存碎片，不過用起來最方便。

● heap和stack中的存儲內容

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

當本次函數調用結束后，局部變量先出棧，然后是參數，最后棧頂指針指向最開始存的地址，也就是主函數中的下一條指令，程序由該點繼續運行。

heap：一般是在堆的頭部用一個字節存放堆的大小。堆中的具體內容有程序員安排。

● 數據結構層面的區別

數據結構方面的堆和棧，這些都是不同的概念。這里的堆實際上指的就是（滿足堆性質的）優先隊列的一種數據結構，第1個元素有最高的優先權；棧實際上就是滿足先進后出的性質的數學或數據結構。雖然堆棧，堆棧的說法是連起來叫，但是他們還是有很大區別的，連著叫只是由于歷史的原因。

● 拓展知識（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）每個JVM的線程都有自己的私有的棧空間，隨線程創建而創建，java的stack存放的是frames，java的stack和c的不同，只是存放本地變量，返回值和調用方法，不允許直接push和pop frames，因為frames可能是有heap分配的，所以java的stack分配的內存不需要是連續的。java的heap是所有線程共享的，堆存放所有runtime data，里面是所有的對象實例和數組，heap是JVM啟動時創建。

（5）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()的形式來創建。那為什么在String str="abc"；中，并沒有通過new()來創建實例，是不是違反了上述原則？其實沒有。

（5.1）關于String str="abc"的內部工作。Java內部將此語句轉化為以下幾個步驟：

(1)先定義一個名為str的對String類的對象引用變量：String str；

(2)在棧中查找有沒有存放值為"abc"的地址，如果沒有，則開辟一個存放字面值為"abc"的地址，接著創建一個新的String類的對象o，并將o的字符串值指向這個地址，而且在棧中這個地址旁邊記下這個引用的對象o。如果已經有了值為"abc"的地址，則查找對象o，并返回o的地址。

(3)將str指向對象o的地址。值得注意的是，一般String類中字符串值都是直接存值的。但像String str="abc"；這種場合下，其字符串值卻是保存了一個指向存在棧中數據的引用！

為了更好地說明這個問題，我們可以通過以下的幾個代碼進行驗證。

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

注意，我們這里并不用str1.equals(str2)；的方式，因為這將比較兩個字符串的值是否相等。==號，根據JDK的說明，只有在兩個引用都指向了同一個對象時才返回true值。而我們在這里要看的是，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

創建了兩個引用。創建了兩個對象。兩個引用分別指向不同的兩個對象。

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

● 數據類型包裝類的值不可修改。不僅僅是String類的值不可修改，所有的數據類型包裝類都不能更改其內部的值。

● 結論與建議：

（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不能成功分配heap的空間，將拋出OutOfMemoryError。

13、解釋內存中的棧(stack)、堆(heap)和方法區(method area)的用法

通常我們定義一個基本數據類型的變量，一個對象的引用，還有就是函數調用的現場保存都使用JVM中的棧空間；而通過new關鍵字和構造器創建的對象則放在堆空間，堆是垃圾收集器管理的主要區域，由于現在的垃圾收集器都采用分代收集算法，所以堆空間還可以細分為新生代和老生代，再具體一點可以分為Eden、Survivor（又可分為From Survivor和To Survivor）、Tenured；方法區和堆都是各個線程共享的內存區域，用于存儲已經被JVM加載的類信息、常量、靜態變量、JIT編譯器編譯后的代碼等數據；程序中的字面量（literal）如直接書寫的100、"hello"和常量都是放在常量池中，常量池是方法區的一部分。棧空間操作起來最快但是棧很小，通常大量的對象都是放在堆空間，棧和堆的大小都可以通過JVM的啟動參數來進行調整，棧空間用光了會引發StackOverflowError，而堆和常量池空間不足則會引發OutOfMemoryError。

String str = new String("hello");

上面的語句中變量str放在棧上，用new創建出來的字符串對象放在堆上，而"hello"這個字面量是放在方法區的。