java代碼垃圾回收

A. java垃圾回收器如何工作

java回收器有gc

以下是工作原理：

強引用（StrongReference）

這個就不多說，我們寫代碼天天在用的就是強引用。如果一個對象被被人擁有強引用，那麼垃圾回收器絕不會回收它。當內存空間不足，Java 虛擬機寧願拋出 OutOfMemoryError 錯誤，使程序異常終止，也不會靠隨意回收具有強引用的對象來解決內存不足問題。

Java 的對象是位於 heap 中的，heap 中對象有強可及對象、軟可及對象、弱可及對象、虛可及對象和不可到達對象。應用的強弱順序是強、軟、弱、和虛。對於對象是屬於哪種可及的對象，由他的最強的引用決定。如下

代碼：

String abc=newString("abc");//1

SoftReference<String> softRef=newSoftReference<String>(abc);//2

WeakReference<String> weakRef =newWeakReference<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 中.然後在釋放虛可及的對象。

B. java中垃圾回收機制的原理

java中垃圾回收機制的原理
推薦一篇文章：
對高性能JAVA代碼之內存管理
更甚者你寫的代碼，GC根本就回收不了，直接系統掛掉。GC是一段程序，不是智能，他只回收他認為的垃圾，而不是回收你認為的垃圾。
GC垃圾回收：
Grabage Collection相信學過JAVA的人都知道這個是什麼意思。但是他是如何工作的呢？
首先，JVM在管理內存的時候對於變數的管理總是分新對象和老對象。新對象也就是開發者new出來的對象，但是由於生命周期短，那麼他佔用的內存並不是馬上釋放，而是被標記為老對象，這個時候該對象還是要存在一段時間。然後由JVM決定他是否是垃圾對象，並進行回收。
所以我們可以知道，垃圾內存並不是用完了馬上就被釋放，所以就會產生內存釋放不及時的現象，從而降低了內存的使用。而當程序浩大的時候。這種現象更為明顯，並且GC的工作也是需要消耗資源的。所以，也就會產生內存浪費。
JVM中的對象生命周期里談內存回收：
對象的生命周期一般分為7個階段：創建階段，應用階段，不可視階段，不可到達階段，可收集階段，終結階段，釋放階段。
創建階段：首先大家看一下，如下兩段代碼：
test1：
for（ int i=0; i《10000; i++）
Object obj=new Object（）;
test2：
Object obj=null;
for（ int i=0; i《10000; i++）
obj=new Object（）;
這兩段代碼都是相同的功能，但是顯然test2的性能要比test1性能要好，內存使用率要高，這是為什麼呢？原因很簡單，test1每次執行for循環都要創建一個Object的臨時對象，但是這些臨時對象由於JVM的GC不能馬上銷毀，所以他們還要存在很長時間，而test2則只是在內存中保存一份對象的引用，而不必創建大量新臨時變數，從而降低了內存的使用。
另外不要對同一個對象初始化多次。例如：
public class A{
private Hashtable table = new Hashtable（）;
public A（）{ table = new Hashtable（）;
// 這里應該去掉，因為table已經被初始化。
}
這樣就new了兩個Hashtable，但是卻只使用了一個。另外一個則沒有被引用。而被忽略掉。浪費了內存。並且由於進行了兩次new操作。也影響了代碼的執行速度。
應用階段：即該對象至少有一個引用在維護他。
不可視階段：即超出該變數的作用域。這里有一個很好的做法，因為JVM在GC的時候並不是馬上進行回收，而是要判斷對象是否被其他引用在維護。所以，這個時候如果我們在使用完一個對象以後對其obj=null或者obj.doSomething（）操作，將其標記為空，可以幫助JVM及時發現這個垃圾對象。
不可到達階段：就是在JVM中找不到對該對象的直接或者間接的引用。
可收集階段，終結階段，釋放階段：此為回收器發現該對象不可到達，finalize方法已經被執行，或者對象空間已被重用的時候。
JAVA的析構方法：
可能不會有人相信，JAVA有析構函數？ 是的，有。因為JAVA所有類都繼承至Object類，而finalize就是Object類的一個方法，這個方法在JAVA中就是類似於C++析構函數。一般來說可以通過重載finalize方法的形式才釋放類中對象。如：
public class A{
public Object a;
public A（）{ a = new Object ;}
protected void finalize（） throws java.lang.Throwable{
a = null; // 標記為空，釋放對象
super.finalize（）; // 遞歸調用超類中的finalize方法。
}
}
當然，什麼時候該方法被調用是由JVM來決定的。..。..。..。..。..。..。..。.
一般來說，我們需要創建一個destory的方法來顯式的調用該方法。然後在finalize也對該方法進行調用，實現雙保險的做法。
由於對象的創建是遞歸式的，也就是先調用超級類的構造，然後依次向下遞歸調用構造函數，所以應該避免在類的構造函數中初始化變數，這樣可以避免不必要的創建對象造成不必要的內存消耗。當然這里也就看出來介面的優勢。
數組的創建：
由於數組需要給定一個長度，所以在不確定數據數量的時候經常會創建過大，或過小的數組的現象。造成不必要的內存浪費，所以可以通過軟引用的方式來告訴JVM及時回收該內存。（軟引用，具體查資料）。
例如：
Object obj = new char［10000000000000000］;
SoftReference ref = new SoftReference（obj）;
共享靜態存儲空間：
我們都知道靜態變數在程序運行期間其內存是共享的，因此有時候為了節約內存工件，將一些變數聲明為靜態變數確實可以起到節約內存空間的作用。但是由於靜態變數生命周期很長，不易被系統回收，所以使用靜態變數要合理，不能盲目的使用。以免適得其反。
因此建議在下面情況下使用：
1，變數所包含的對象體積較大，佔用內存過多。
2，變數所包含對象生命周期較長。
3，變數所包含數據穩定。
4，該類的對象實例有對該變數所包含的對象的共享需求。（也就是說是否需要作為全局變數）。
對象重用與GC：
有的時候，如資料庫操作對象，一般情況下我們都需要在各個不同模塊間使用，所以這樣的對象需要進行重用以提高性能。也有效的避免了反復創建對象引起的性能下降。
一般來說對象池是一個不錯的注意。如下：
public abstarct class ObjectPool{
private Hashtable locked，unlocked;
private long expirationTime;
abstract Object create（）;
abstract void expire（ Object o）;
abstract void validate（ Object o）;
synchronized Object getObject（）{。..};
synchronized void freeObject（Object o）{。..};
這樣我們就完成了一個對象池，我們可以將通過對應的方法來存取刪除所需對象。來維護這快內存提高內存重用。
當然也可以通過調用System.gc（）強制系統進行垃圾回收操作。當然這樣的代價是需要消耗一些cpu資源。
不要提前創建對象：
盡量在需要的時候創建對象，重復的分配，構造對象可能會因為垃圾回收做額外的工作降低性能。
JVM內存參數調優：
強制內存回收對於系統自動的內存回收機制會產生負面影響，會加大系統自動回收的處理時間，所以應該盡量避免顯式使用System.gc（），
JVM的設置可以提高系統的性能。例如：
java -XX:NewSize=128m -XX:MaxNewSize=128m -XX:SurvivorRatio=8 -Xms512m -Xmx512m
具體可以查看java幫助文檔。我們主要介紹程序設計方面的性能提高。
JAVA程序設計中有關內存管理的其他經驗：
根據JVM內存管理的工作原理，可以通過一些技巧和方式讓JVM做GC處理時更加有效。，從而提高內存使用和縮短GC的執行時間。
1，盡早釋放無用對象的引用。即在不使用對象的引用後設置為空，可以加速GC的工作。（當然如果是返回值。..。.）
2，盡量少用finalize函數，此函數是JAVA給程序員提供的一個釋放對象或資源的機會，但是卻會加大GC工作量。
3，如果需要使用到圖片，可以使用soft應用類型，它可以盡可能將圖片讀入內存而不引起OutOfMemory.
4，注意集合數據類型的數據結構，往往數據結構越復雜，GC工作量更大，處理更復雜。
5，盡量避免在默認構造器（構造函數）中創建，初始化大量的對象。
6，盡量避免強制系統做垃圾回收。會增加系統做垃圾回收的最終時間降低性能。
7，盡量避免顯式申請數組，如果不得不申請數組的話，要盡量准確估算數組大小。
8，如果在做遠程方法調用。要盡量減少傳遞的對象大小。或者使用瞬間值避免不必要數據的傳遞。
9，盡量在合適的情況下使用對象池來提高系統性能減少內存開銷，當然，對象池不能過於龐大，會適得其反.