Java設(shè)計模式筆試題（10~13題）

10、談?wù)?JVM 的內(nèi)存結(jié)構(gòu)和內(nèi)存分配

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

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

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

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

● java內(nèi)存分配

● 基礎(chǔ)數(shù)據(jù)類型直接在棧空間分配；

● 方法的形式參數(shù)，直接在棧空間分配，當(dāng)方法調(diào)用完成后從棧空間回收；

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

● 方法的引用參數(shù)，在棧空間分配一個地址空間，并指向堆空間的對象區(qū)，當(dāng)方法調(diào)用完后從棧空間回收；

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

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

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

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

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

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

● 強(qiáng)引用（StrongReference）

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

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堆中創(chuàng)建內(nèi)容為“abc”的對象，并建立abc到該對象的強(qiáng)引用，該對象是強(qiáng)可及的。

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

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

第五行執(zhí)行之后變成弱可及的。

● 軟引用（SoftReference）

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

以上面的softRef為例：

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

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

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

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

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

● 弱引用（WeakReference）

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

● 虛引用（PhantomReference）

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

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

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

12、heap和stack有什么區(qū)別？

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

● 申請方式

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

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

● 申請后系統(tǒng)的響應(yīng)

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

heap：首先應(yīng)該知道操作系統(tǒng)有一個記錄空閑內(nèi)存地址的鏈表，當(dāng)系統(tǒng)收到程序的申請時，

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

● 申請大小的限制

stack：棧是向低地址擴(kuò)展的數(shù)據(jù)結(jié)構(gòu)，是一塊連續(xù)的內(nèi)存的區(qū)域。這句話的意思是棧頂?shù)牡刂泛蜅５淖畲笕萘渴窍到y(tǒng)預(yù)先規(guī)定好的，在WINDOWS下，棧的大小是2M（也有的說是1M，總之是一個編譯時就確定的常數(shù)），如果申請的空間超過棧的剩余空間時，將提示overflow。因此，能從棧獲得的空間較小。

heap：堆是向高地址擴(kuò)展的數(shù)據(jù)結(jié)構(gòu)，是不連續(xù)的內(nèi)存區(qū)域。這是由于系統(tǒng)是用鏈表來存儲的空閑內(nèi)存地址的，自然是不連續(xù)的，而鏈表的遍歷方向是由低地址向高地址。堆的大小受限于計算機(jī)系統(tǒng)中有效的虛擬內(nèi)存。由此可見，堆獲得的空間比較靈活，也比較大。

● 申請效率的比較：

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

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

● heap和stack中的存儲內(nèi)容

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

當(dāng)本次函數(shù)調(diào)用結(jié)束后，局部變量先出棧，然后是參數(shù)，最后棧頂指針指向最開始存的地址，也就是主函數(shù)中的下一條指令，程序由該點(diǎn)繼續(xù)運(yùn)行。

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

● 數(shù)據(jù)結(jié)構(gòu)層面的區(qū)別

數(shù)據(jù)結(jié)構(gòu)方面的堆和棧，這些都是不同的概念。這里的堆實際上指的就是（滿足堆性質(zhì)的）優(yōu)先隊列的一種數(shù)據(jù)結(jié)構(gòu)，第1個元素有最高的優(yōu)先權(quán)；棧實際上就是滿足先進(jìn)后出的性質(zhì)的數(shù)學(xué)或數(shù)據(jù)結(jié)構(gòu)。雖然堆棧，堆棧的說法是連起來叫，但是他們還是有很大區(qū)別的，連著叫只是由于歷史的原因。

● 拓展知識（Java中堆棧的應(yīng)用）

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

（2）棧的優(yōu)勢是，存取速度比堆要快，僅次于直接位于CPU中的寄存器。但缺點(diǎn)是，存在棧中的數(shù)據(jù)大小與生存期必須是確定的，缺乏靈活性。另外，棧數(shù)據(jù)可以共享，詳見第3點(diǎn)。堆的優(yōu)勢是可以動態(tài)地分配內(nèi)存大小，生存期也不必事先告訴編譯器，Java的垃圾回收器會自動收走這些不再使用的數(shù)據(jù)。但缺點(diǎn)是，由于要在運(yùn)行時動態(tài)分配內(nèi)存，存取速度較慢。

（3）Java中的數(shù)據(jù)類型有兩種。

一種是基本類型(primitive types)，共有8種，即int，short，long，byte，float，double，boolean，char(注意，并沒有string的基本類型)。這種類型的定義是通過諸如int a=3;long b=255L;的形式來定義的，稱為自動變量（自動變量：只在定義它們的時候才創(chuàng)建，在定義它們的函數(shù)返回時系統(tǒng)回收變量所占存儲空間。對這些變量存儲空間的分配和回收是由系統(tǒng)自動完成的。）。值得注意的是，自動變量存的是字面值，不是類的實例，即不是類的引用，這里并沒有類的存在。如int a=3;這里的a是一個指向int類型的引用，指向3這個字面值。這些字面值的數(shù)據(jù)，由于大小可知，生存期可知(這些字面值固定定義在某個程序塊里面，程序塊退出后，字段值就消失了)，出于追求速度的原因，就存在于棧中。另外，棧有一個很重要的特殊性，就是存在棧中的數(shù)據(jù)可以共享。

假設(shè)我們同時定義：

int a=3;
int b=3;

編譯器先處理int a=3；首先它會在棧中創(chuàng)建一個變量為a的引用，然后查找有沒有字面值為3的地址，沒找到，就開辟一個存放3這個字面值的地址，然后將a指向3的地址。接著處理int b=3；在創(chuàng)建完b的引用變量后，由于在棧中已經(jīng)有3這個字面值，便將b直接指向3的地址。這樣，就出現(xiàn)了a與b同時均指向3的情況。

特別注意的是，這種字面值的引用與類對象的引用不同。假定兩個類對象的引用同時指向一個對象，如果一個對象引用變量修改了這個對象的內(nèi)部狀態(tài)，那么另一個對象引用變量也即刻反映出這個變化。相反，通過字面值的引用來修改其值，不會導(dǎo)致另一個指向此字面值的引用的值也跟著改變的情況。如上例，我們定義完a與b的值后，再令a=4；那么，b不會等于4，還是等于3。在編譯器內(nèi)部，遇到a=4；時，它就會重新搜索棧中是否有4的字面值，如果沒有，重新開辟地址存放4的值；如果已經(jīng)有了，則直接將a指向這個地址。因此a值的改變不會影響到b的值。

另一種是包裝類數(shù)據(jù)，如Integer，String，Double等將相應(yīng)的基本數(shù)據(jù)類型包裝起來的類。這些類數(shù)據(jù)全部存在于堆中，Java用new()語句來顯示地告訴編譯器，在運(yùn)行時才根據(jù)需要動態(tài)創(chuàng)建，因此比較靈活，但缺點(diǎn)是要占用更多的時間。

（4）每個JVM的線程都有自己的私有的棧空間，隨線程創(chuàng)建而創(chuàng)建，java的stack存放的是frames，java的stack和c的不同，只是存放本地變量，返回值和調(diào)用方法，不允許直接push和pop frames，因為frames可能是有heap分配的，所以java的stack分配的內(nèi)存不需要是連續(xù)的。java的heap是所有線程共享的，堆存放所有runtime data，里面是所有的對象實例和數(shù)組，heap是JVM啟動時創(chuàng)建。

（5）String是一個特殊的包裝類數(shù)據(jù)。即可以用String str=new String("abc");的形式來創(chuàng)建，也可以用String str="abc"；的形式來創(chuàng)建(作為對比，在JDK 5.0之前，你從未見過Integer i=3;的表達(dá)式，因為類與字面值是不能通用的，除了String。而在JDK 5.0中，這種表達(dá)式是可以的！因為編譯器在后臺進(jìn)行Integer i=new Integer(3)的轉(zhuǎn)換)。前者是規(guī)范的類的創(chuàng)建過程，即在Java中，一切都是對象，而對象是類的實例，全部通過new()的形式來創(chuàng)建。那為什么在String str="abc"；中，并沒有通過new()來創(chuàng)建實例，是不是違反了上述原則？其實沒有。

（5.1）關(guān)于String str="abc"的內(nèi)部工作。Java內(nèi)部將此語句轉(zhuǎn)化為以下幾個步驟：

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

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

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

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

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

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

結(jié)果說明，JVM創(chuàng)建了兩個引用str1和str2，但只創(chuàng)建了一個對象，而且兩個引用都指向了這個對象。我們再來更進(jìn)一步，將以上代碼改成：

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

這就是說，賦值的變化導(dǎo)致了類對象引用的變化，str1指向了另外一個新對象！而str2仍舊指向原來的對象。上例中，當(dāng)我們將str1的值改為"bcd"時，JVM發(fā)現(xiàn)在棧中沒有存放該值的地址，便開辟了這個地址，并創(chuàng)建了一個新的對象，其字符串的值指向這個地址。

事實上，String類被設(shè)計成為不可改變(immutable)的類。如果你要改變其值，可以，但JVM在運(yùn)行時根據(jù)新值悄悄創(chuàng)建了一個新對象，然后將這個對象的地址返回給原來類的引用。這個創(chuàng)建過程雖說是完全自動進(jìn)行的，但它畢竟占用了更多的時間。在對時間要求比較敏感的環(huán)境中，會帶有一定的不良影響。

再修改原來代碼：

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并沒有創(chuàng)建新對象)。當(dāng)str1改完其值后，再創(chuàng)建一個String的引用str4，并指向因str1修改值而創(chuàng)建的新的對象。可以發(fā)現(xiàn)，這回str4也沒有創(chuàng)建新的對象，從而再次實現(xiàn)棧中數(shù)據(jù)的共享。

我們再接著看以下的代碼。

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

創(chuàng)建了兩個引用。創(chuàng)建了兩個對象。兩個引用分別指向不同的兩個對象。

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

● 數(shù)據(jù)類型包裝類的值不可修改。不僅僅是String類的值不可修改，所有的數(shù)據(jù)類型包裝類都不能更改其內(nèi)部的值。

● 結(jié)論與建議：

（1）我們在使用諸如String str="abc"；的格式定義類時，總是想當(dāng)然地認(rèn)為，我們創(chuàng)建了String類的對象str。擔(dān)心陷阱！對象可能并沒有被創(chuàng)建！唯一可以肯定的是，指向String類的引用被創(chuàng)建了。至于這個引用到底是否指向了一個新的對象，必須根據(jù)上下文來考慮，除非你通過new()方法來顯要地創(chuàng)建一個新的對象。因此，更為準(zhǔn)確的說法是，我們創(chuàng)建了一個指向String類的對象的引用變量str，這個對象引用變量指向了某個值為"abc"的String類。清醒地認(rèn)識到這一點(diǎn)對排除程序中難以發(fā)現(xiàn)的bug是很有幫助的。

（2）使用String str="abc"；的方式，可以在一定程度上提高程序的運(yùn)行速度，因為JVM會自動根據(jù)棧中數(shù)據(jù)的實際情況來決定是否有必要創(chuàng)建新對象。而對于String str=new String("abc")；的代碼，則一概在堆中創(chuàng)建新對象，而不管其字符串值是否相等，是否有必要創(chuàng)建新對象，從而加重了程序的負(fù)擔(dān)。這個思想應(yīng)該是享元模式的思想，但JDK的內(nèi)部在這里實現(xiàn)是否應(yīng)用了這個模式，不得而知。

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

（4）由于String類的immutable性質(zhì)，當(dāng)String變量需要經(jīng)常變換其值時，應(yīng)該考慮使用StringBuffer類，以提高程序效率。

如果java不能成功分配heap的空間，將拋出OutOfMemoryError。

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

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

String str = new String("hello");

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