一：垃圾回收機制的意義
java 語言中一個顯著的特點就是引入了java回收機制，是c++程序員最頭疼的內存管理的問題迎刃而解，它使得java程序員在編寫程序的時候不在考慮內存管理。由於有個垃圾回收機制，java中的額對象不在有“作用域”的概念，只有對象的引用才有“作用域”。垃圾回收可以有效的防止內存洩露，有效的使用空閒的內存；
內存洩露：指該內存空間使用完畢後未回收，在不涉及複雜數據結構的一般情況下，java的內存洩露表現為一個內存對象的生命週期超出了程序需要它的時間長度，我們有是也將其稱為“對象遊離”；
二：垃圾回收機制的算法
java語言規範沒有明確的說明JVM 使用哪種垃圾回收算法，但是任何一種垃圾回收算法一般要做兩件基本事情：（1）發現無用的信息對象；（2）回收將無用對象佔用的內存空間。使該空間可被程序再次使用。
1。引用計數法（Reference Counting Collector）
1.1:算法分析：
引用計數算法是垃圾回收器中的早起策略，在這種方法中，堆中的每個對象實例都有一個引用計數器，點一個對象被創建時，且該對象實例分配給一個變量，該變量計數設置為1 ，當任何其他變量賦值為這個對象的引用時，計數加1 ，（a=b ，則b引用的對象實例計數器+1）但當一個對象實例的某個引用超過了生命週期或者被設置為一個新值時，對象實例的引用計數器減1，任何引用計數器為0 的對象實例可以當做垃圾收集。 當一個對象的實例被垃圾收集是，它引用的任何對象實例的引用計數器減1.
一、垃圾回收機制的意義
Java語言中一個顯著的特點就是引入了垃圾回收機制，使c++程序員最頭疼的內存管理的問題迎刃而解，它使得Java程序員在編寫程序的時候不再需要考慮內存管理。由於有個垃圾回收機制，Java中的對象不再有“作用域”的概念，只有對象的引用才有“作用域”。垃圾回收可以有效的防止內存洩露，有效的使用空閒的內存。
ps:內存洩露是指該內存空間使用完畢之後未回收，在不涉及複雜數據結構的一般情況下，Java 的內存洩露表現為一個內存對象的生命週期超出了程序需要它的時間長度，我們有時也將其稱為“對象遊離”。
二、垃圾回收機制中的算法
Java語言規範沒有明確地說明JVM使用哪種垃圾回收算法，但是任何一種垃圾回收算法一般要做2件基本的事情：（1）發現無用信息對象；（2）回收被無用對象佔用的內存空間，使該空間可被程序再次使用。
1.引用計數法(Reference Counting Collector)
1.1算法分析
引用計數是垃圾收集器中的早期策略。在這種方法中，堆中每個對象實例都有一個引用計數。當一個對象被創建時，且將該對象實例分配給一個變量，該變量計數設置為1。當任何其它變量被賦值為這個對象的引用時，計數加1（a = b,則b引用的對象實例的計數器+1），但當一個對象實例的某個引用超過了生命週期或者被設置為一個新值時，對象實例的引用計數器減1。任何引用計數器為0的對象實例可以被當作垃圾收集。當一個對象實例被垃圾收集時，它引用的任何對象實例的引用計數器減1。
1.2優缺點
優點：
引用計數收集器可以很快的執行，交織在程序運行中。對程序需要不被長時間打斷的實時環境比較有利。
缺點：
無法檢測出循環引用。如父對象有一個對子對象的引用，子對象反過來引用父對象。這樣，他們的引用計數永遠不可能為0.
1.3引用計數算法無法解決循環引用問題，例如：
ublic class Main {
public static void main(String[] args) {
MyObject object1 = new MyObject();
MyObject object2 = new MyObject();
object1.object = object2;
object2.object = object1;
object1 = null;
object2 = null;
}
}
最後面兩句將object1和object2賦值為null，也就是說object1和object2指向的對象已經不可能再被訪問，但是由於它們互相引用對方，導致它們的引用計數器都不為0，那麼垃圾收集器就永遠不會回收它們。
2.tracing算法(Tracing Collector) 或 標記-清除算法(mark and sweep)
2.1根搜索算法
一：垃圾回收機制的意義
java 語言中一個顯著的特點就是引入了java回收機制，是c++程序員最頭疼的內存管理的問題迎刃而解，它使得java程序員在編寫程序的時候不在考慮內存管理。由於有個垃圾回收機制，java中的額對象不在有“作用域”的概念，只有對象的引用才有“作用域”。垃圾回收可以有效的防止內存洩露，有效的使用空閒的內存；
內存洩露：指該內存空間使用完畢後未回收，在不涉及複雜數據結構的一般情況下，java的內存洩露表現為一個內存對象的生命週期超出了程序需要它的時間長度，我們有是也將其稱為“對象遊離”；
二：垃圾回收機制的算法
java語言規範沒有明確的說明JVM 使用哪種垃圾回收算法，但是任何一種垃圾回收算法一般要做兩件基本事情：（1）發現無用的信息對象；（2）回收將無用對象佔用的內存空間。使該空間可被程序再次使用。
1。引用計數法（Reference Counting Collector）
1.1:算法分析：
引用計數算法是垃圾回收器中的早起策略，在這種方法中，堆中的每個對象實例都有一個引用計數器，點一個對象被創建時，且該對象實例分配給一個變量，該變量計數設置為1 ，當任何其他變量賦值為這個對象的引用時，計數加1 ，（a=b ，則b引用的對象實例計數器+1）但當一個對象實例的某個引用超過了生命週期或者被設置為一個新值時，對象實例的引用計數器減1，任何引用計數器為0 的對象實例可以當做垃圾收集。 當一個對象的實例被垃圾收集是，它引用的任何對象實例的引用計數器減1.
一、垃圾回收機制的意義
Java語言中一個顯著的特點就是引入了垃圾回收機制，使c++程序員最頭疼的內存管理的問題迎刃而解，它使得Java程序員在編寫程序的時候不再需要考慮內存管理。由於有個垃圾回收機制，Java中的對象不再有“作用域”的概念，只有對象的引用才有“作用域”。垃圾回收可以有效的防止內存洩露，有效的使用空閒的內存。
ps:內存洩露是指該內存空間使用完畢之後未回收，在不涉及複雜數據結構的一般情況下，Java 的內存洩露表現為一個內存對象的生命週期超出了程序需要它的時間長度，我們有時也將其稱為“對象遊離”。
二、垃圾回收機制中的算法
Java語言規範沒有明確地說明JVM使用哪種垃圾回收算法，但是任何一種垃圾回收算法一般要做2件基本的事情：（1）發現無用信息對象；（2）回收被無用對象佔用的內存空間，使該空間可被程序再次使用。
1.引用計數法(Reference Counting Collector)
1.1算法分析
引用計數是垃圾收集器中的早期策略。在這種方法中，堆中每個對象實例都有一個引用計數。當一個對象被創建時，且將該對象實例分配給一個變量，該變量計數設置為1。當任何其它變量被賦值為這個對象的引用時，計數加1（a = b,則b引用的對象實例的計數器+1），但當一個對象實例的某個引用超過了生命週期或者被設置為一個新值時，對象實例的引用計數器減1。任何引用計數器為0的對象實例可以被當作垃圾收集。當一個對象實例被垃圾收集時，它引用的任何對象實例的引用計數器減1。
1.2優缺點
優點：
引用計數收集器可以很快的執行，交織在程序運行中。對程序需要不被長時間打斷的實時環境比較有利。
缺點：
無法檢測出循環引用。如父對象有一個對子對象的引用，子對象反過來引用父對象。這樣，他們的引用計數永遠不可能為0.
1.3引用計數算法無法解決循環引用問題，例如：
ublic class Main {
public static void main(String[] args) {
MyObject object1 = new MyObject();
MyObject object2 = new MyObject();
object1.object = object2;
object2.object = object1;
object1 = null;
object2 = null;
}
}
最後面兩句將object1和object2賦值為null，也就是說object1和object2指向的對象已經不可能再被訪問，但是由於它們互相引用對方，導致它們的引用計數器都不為0，那麼垃圾收集器就永遠不會回收它們。
2.tracing算法(Tracing Collector) 或 標記-清除算法(mark and sweep)
2.1根搜索算法
根搜索算法是從離散數學中的圖論引入的，程序把所有的引用關係看作一張圖，從一個節點GC ROOT開始，尋找對應的引用節點，找到這個節點以後，繼續尋找這個節點的引用節點，當所有的引用節點尋找完畢之後，剩餘的節點則被認為是沒有被引用到的節點，即無用的節點。
java中可作為GC Root的對象有
1.虛擬機棧中引用的對象（本地變量表）
2.方法區中靜態屬性引用的對象
3. 方法區中常量引用的對象
4.本地方法棧中引用的對象（Native對象）
2.2tracing算法的示意圖
一：垃圾回收機制的意義
java 語言中一個顯著的特點就是引入了java回收機制，是c++程序員最頭疼的內存管理的問題迎刃而解，它使得java程序員在編寫程序的時候不在考慮內存管理。由於有個垃圾回收機制，java中的額對象不在有“作用域”的概念，只有對象的引用才有“作用域”。垃圾回收可以有效的防止內存洩露，有效的使用空閒的內存；
內存洩露：指該內存空間使用完畢後未回收，在不涉及複雜數據結構的一般情況下，java的內存洩露表現為一個內存對象的生命週期超出了程序需要它的時間長度，我們有是也將其稱為“對象遊離”；
二：垃圾回收機制的算法
java語言規範沒有明確的說明JVM 使用哪種垃圾回收算法，但是任何一種垃圾回收算法一般要做兩件基本事情：（1）發現無用的信息對象；（2）回收將無用對象佔用的內存空間。使該空間可被程序再次使用。
1。引用計數法（Reference Counting Collector）
1.1:算法分析：
引用計數算法是垃圾回收器中的早起策略，在這種方法中，堆中的每個對象實例都有一個引用計數器，點一個對象被創建時，且該對象實例分配給一個變量，該變量計數設置為1 ，當任何其他變量賦值為這個對象的引用時，計數加1 ，（a=b ，則b引用的對象實例計數器+1）但當一個對象實例的某個引用超過了生命週期或者被設置為一個新值時，對象實例的引用計數器減1，任何引用計數器為0 的對象實例可以當做垃圾收集。 當一個對象的實例被垃圾收集是，它引用的任何對象實例的引用計數器減1.
一、垃圾回收機制的意義
Java語言中一個顯著的特點就是引入了垃圾回收機制，使c++程序員最頭疼的內存管理的問題迎刃而解，它使得Java程序員在編寫程序的時候不再需要考慮內存管理。由於有個垃圾回收機制，Java中的對象不再有“作用域”的概念，只有對象的引用才有“作用域”。垃圾回收可以有效的防止內存洩露，有效的使用空閒的內存。
ps:內存洩露是指該內存空間使用完畢之後未回收，在不涉及複雜數據結構的一般情況下，Java 的內存洩露表現為一個內存對象的生命週期超出了程序需要它的時間長度，我們有時也將其稱為“對象遊離”。
二、垃圾回收機制中的算法
Java語言規範沒有明確地說明JVM使用哪種垃圾回收算法，但是任何一種垃圾回收算法一般要做2件基本的事情：（1）發現無用信息對象；（2）回收被無用對象佔用的內存空間，使該空間可被程序再次使用。
1.引用計數法(Reference Counting Collector)
1.1算法分析
引用計數是垃圾收集器中的早期策略。在這種方法中，堆中每個對象實例都有一個引用計數。當一個對象被創建時，且將該對象實例分配給一個變量，該變量計數設置為1。當任何其它變量被賦值為這個對象的引用時，計數加1（a = b,則b引用的對象實例的計數器+1），但當一個對象實例的某個引用超過了生命週期或者被設置為一個新值時，對象實例的引用計數器減1。任何引用計數器為0的對象實例可以被當作垃圾收集。當一個對象實例被垃圾收集時，它引用的任何對象實例的引用計數器減1。
1.2優缺點
優點：
引用計數收集器可以很快的執行，交織在程序運行中。對程序需要不被長時間打斷的實時環境比較有利。
缺點：
無法檢測出循環引用。如父對象有一個對子對象的引用，子對象反過來引用父對象。這樣，他們的引用計數永遠不可能為0.
1.3引用計數算法無法解決循環引用問題，例如：
ublic class Main {
public static void main(String[] args) {
MyObject object1 = new MyObject();
MyObject object2 = new MyObject();
object1.object = object2;
object2.object = object1;
object1 = null;
object2 = null;
}
}
最後面兩句將object1和object2賦值為null，也就是說object1和object2指向的對象已經不可能再被訪問，但是由於它們互相引用對方，導致它們的引用計數器都不為0，那麼垃圾收集器就永遠不會回收它們。
2.tracing算法(Tracing Collector) 或 標記-清除算法(mark and sweep)
2.1根搜索算法
根搜索算法是從離散數學中的圖論引入的，程序把所有的引用關係看作一張圖，從一個節點GC ROOT開始，尋找對應的引用節點，找到這個節點以後，繼續尋找這個節點的引用節點，當所有的引用節點尋找完畢之後，剩餘的節點則被認為是沒有被引用到的節點，即無用的節點。
java中可作為GC Root的對象有
1.虛擬機棧中引用的對象（本地變量表）
2.方法區中靜態屬性引用的對象
3. 方法區中常量引用的對象
4.本地方法棧中引用的對象（Native對象）
2.2tracing算法的示意圖
2.3標記-清除算法分析
標記-清除算法採用從根集合進行掃描，對存活的對象對象標記，標記完畢後，再掃描整個空間中未被標記的對象，進行回收，如上圖所示。標記-清除算法不需要進行對象的移動，並且僅對不存活的對象進行處理，在存活對象比較多的情況下極為高效，但由於標記-清除算法直接回收不存活的對象，因此會造成內存碎片。
3.compacting算法 或 標記-整理算法
一：垃圾回收機制的意義
java 語言中一個顯著的特點就是引入了java回收機制，是c++程序員最頭疼的內存管理的問題迎刃而解，它使得java程序員在編寫程序的時候不在考慮內存管理。由於有個垃圾回收機制，java中的額對象不在有“作用域”的概念，只有對象的引用才有“作用域”。垃圾回收可以有效的防止內存洩露，有效的使用空閒的內存；
內存洩露：指該內存空間使用完畢後未回收，在不涉及複雜數據結構的一般情況下，java的內存洩露表現為一個內存對象的生命週期超出了程序需要它的時間長度，我們有是也將其稱為“對象遊離”；
二：垃圾回收機制的算法
java語言規範沒有明確的說明JVM 使用哪種垃圾回收算法，但是任何一種垃圾回收算法一般要做兩件基本事情：（1）發現無用的信息對象；（2）回收將無用對象佔用的內存空間。使該空間可被程序再次使用。
1。引用計數法（Reference Counting Collector）
1.1:算法分析：
引用計數算法是垃圾回收器中的早起策略，在這種方法中，堆中的每個對象實例都有一個引用計數器，點一個對象被創建時，且該對象實例分配給一個變量，該變量計數設置為1 ，當任何其他變量賦值為這個對象的引用時，計數加1 ，（a=b ，則b引用的對象實例計數器+1）但當一個對象實例的某個引用超過了生命週期或者被設置為一個新值時，對象實例的引用計數器減1，任何引用計數器為0 的對象實例可以當做垃圾收集。 當一個對象的實例被垃圾收集是，它引用的任何對象實例的引用計數器減1.
一、垃圾回收機制的意義
Java語言中一個顯著的特點就是引入了垃圾回收機制，使c++程序員最頭疼的內存管理的問題迎刃而解，它使得Java程序員在編寫程序的時候不再需要考慮內存管理。由於有個垃圾回收機制，Java中的對象不再有“作用域”的概念，只有對象的引用才有“作用域”。垃圾回收可以有效的防止內存洩露，有效的使用空閒的內存。
ps:內存洩露是指該內存空間使用完畢之後未回收，在不涉及複雜數據結構的一般情況下，Java 的內存洩露表現為一個內存對象的生命週期超出了程序需要它的時間長度，我們有時也將其稱為“對象遊離”。
二、垃圾回收機制中的算法
Java語言規範沒有明確地說明JVM使用哪種垃圾回收算法，但是任何一種垃圾回收算法一般要做2件基本的事情：（1）發現無用信息對象；（2）回收被無用對象佔用的內存空間，使該空間可被程序再次使用。
1.引用計數法(Reference Counting Collector)
1.1算法分析
引用計數是垃圾收集器中的早期策略。在這種方法中，堆中每個對象實例都有一個引用計數。當一個對象被創建時，且將該對象實例分配給一個變量，該變量計數設置為1。當任何其它變量被賦值為這個對象的引用時，計數加1（a = b,則b引用的對象實例的計數器+1），但當一個對象實例的某個引用超過了生命週期或者被設置為一個新值時，對象實例的引用計數器減1。任何引用計數器為0的對象實例可以被當作垃圾收集。當一個對象實例被垃圾收集時，它引用的任何對象實例的引用計數器減1。
1.2優缺點
優點：
引用計數收集器可以很快的執行，交織在程序運行中。對程序需要不被長時間打斷的實時環境比較有利。
缺點：
無法檢測出循環引用。如父對象有一個對子對象的引用，子對象反過來引用父對象。這樣，他們的引用計數永遠不可能為0.
1.3引用計數算法無法解決循環引用問題，例如：
ublic class Main {
public static void main(String[] args) {
MyObject object1 = new MyObject();
MyObject object2 = new MyObject();
object1.object = object2;
object2.object = object1;
object1 = null;
object2 = null;
}
}
最後面兩句將object1和object2賦值為null，也就是說object1和object2指向的對象已經不可能再被訪問，但是由於它們互相引用對方，導致它們的引用計數器都不為0，那麼垃圾收集器就永遠不會回收它們。
2.tracing算法(Tracing Collector) 或 標記-清除算法(mark and sweep)
2.1根搜索算法
根搜索算法是從離散數學中的圖論引入的，程序把所有的引用關係看作一張圖，從一個節點GC ROOT開始，尋找對應的引用節點，找到這個節點以後，繼續尋找這個節點的引用節點，當所有的引用節點尋找完畢之後，剩餘的節點則被認為是沒有被引用到的節點，即無用的節點。
java中可作為GC Root的對象有
1.虛擬機棧中引用的對象（本地變量表）
2.方法區中靜態屬性引用的對象
3. 方法區中常量引用的對象
4.本地方法棧中引用的對象（Native對象）
2.2tracing算法的示意圖
2.3標記-清除算法分析
標記-清除算法採用從根集合進行掃描，對存活的對象對象標記，標記完畢後，再掃描整個空間中未被標記的對象，進行回收，如上圖所示。標記-清除算法不需要進行對象的移動，並且僅對不存活的對象進行處理，在存活對象比較多的情況下極為高效，但由於標記-清除算法直接回收不存活的對象，因此會造成內存碎片。
3.compacting算法 或 標記-整理算法
標記-整理算法採用標記-清除算法一樣的方式進行對象的標記，但在清除時不同，在回收不存活的對象佔用的空間後，會將所有的存活對象往左端空閒空間移動，並更新對應的指針。標記-整理算法是在標記-清除算法的基礎上，又進行了對象的移動，因此成本更高，但是卻解決了內存碎片的問題。在基於Compacting算法的收集器的實現中，一般增加句柄和句柄表。
4.copying算法(Compacting Collector)
一：垃圾回收機制的意義
java 語言中一個顯著的特點就是引入了java回收機制，是c++程序員最頭疼的內存管理的問題迎刃而解，它使得java程序員在編寫程序的時候不在考慮內存管理。由於有個垃圾回收機制，java中的額對象不在有“作用域”的概念，只有對象的引用才有“作用域”。垃圾回收可以有效的防止內存洩露，有效的使用空閒的內存；
內存洩露：指該內存空間使用完畢後未回收，在不涉及複雜數據結構的一般情況下，java的內存洩露表現為一個內存對象的生命週期超出了程序需要它的時間長度，我們有是也將其稱為“對象遊離”；
二：垃圾回收機制的算法
java語言規範沒有明確的說明JVM 使用哪種垃圾回收算法，但是任何一種垃圾回收算法一般要做兩件基本事情：（1）發現無用的信息對象；（2）回收將無用對象佔用的內存空間。使該空間可被程序再次使用。
1。引用計數法（Reference Counting Collector）
1.1:算法分析：
引用計數算法是垃圾回收器中的早起策略，在這種方法中，堆中的每個對象實例都有一個引用計數器，點一個對象被創建時，且該對象實例分配給一個變量，該變量計數設置為1 ，當任何其他變量賦值為這個對象的引用時，計數加1 ，（a=b ，則b引用的對象實例計數器+1）但當一個對象實例的某個引用超過了生命週期或者被設置為一個新值時，對象實例的引用計數器減1，任何引用計數器為0 的對象實例可以當做垃圾收集。 當一個對象的實例被垃圾收集是，它引用的任何對象實例的引用計數器減1.
一、垃圾回收機制的意義
Java語言中一個顯著的特點就是引入了垃圾回收機制，使c++程序員最頭疼的內存管理的問題迎刃而解，它使得Java程序員在編寫程序的時候不再需要考慮內存管理。由於有個垃圾回收機制，Java中的對象不再有“作用域”的概念，只有對象的引用才有“作用域”。垃圾回收可以有效的防止內存洩露，有效的使用空閒的內存。
ps:內存洩露是指該內存空間使用完畢之後未回收，在不涉及複雜數據結構的一般情況下，Java 的內存洩露表現為一個內存對象的生命週期超出了程序需要它的時間長度，我們有時也將其稱為“對象遊離”。
二、垃圾回收機制中的算法
Java語言規範沒有明確地說明JVM使用哪種垃圾回收算法，但是任何一種垃圾回收算法一般要做2件基本的事情：（1）發現無用信息對象；（2）回收被無用對象佔用的內存空間，使該空間可被程序再次使用。
1.引用計數法(Reference Counting Collector)
1.1算法分析
引用計數是垃圾收集器中的早期策略。在這種方法中，堆中每個對象實例都有一個引用計數。當一個對象被創建時，且將該對象實例分配給一個變量，該變量計數設置為1。當任何其它變量被賦值為這個對象的引用時，計數加1（a = b,則b引用的對象實例的計數器+1），但當一個對象實例的某個引用超過了生命週期或者被設置為一個新值時，對象實例的引用計數器減1。任何引用計數器為0的對象實例可以被當作垃圾收集。當一個對象實例被垃圾收集時，它引用的任何對象實例的引用計數器減1。
1.2優缺點
優點：
引用計數收集器可以很快的執行，交織在程序運行中。對程序需要不被長時間打斷的實時環境比較有利。
缺點：
無法檢測出循環引用。如父對象有一個對子對象的引用，子對象反過來引用父對象。這樣，他們的引用計數永遠不可能為0.
1.3引用計數算法無法解決循環引用問題，例如：
ublic class Main {
public static void main(String[] args) {
MyObject object1 = new MyObject();
MyObject object2 = new MyObject();
object1.object = object2;
object2.object = object1;
object1 = null;
object2 = null;
}
}
最後面兩句將object1和object2賦值為null，也就是說object1和object2指向的對象已經不可能再被訪問，但是由於它們互相引用對方，導致它們的引用計數器都不為0，那麼垃圾收集器就永遠不會回收它們。
2.tracing算法(Tracing Collector) 或 標記-清除算法(mark and sweep)
2.1根搜索算法
根搜索算法是從離散數學中的圖論引入的，程序把所有的引用關係看作一張圖，從一個節點GC ROOT開始，尋找對應的引用節點，找到這個節點以後，繼續尋找這個節點的引用節點，當所有的引用節點尋找完畢之後，剩餘的節點則被認為是沒有被引用到的節點，即無用的節點。
java中可作為GC Root的對象有
1.虛擬機棧中引用的對象（本地變量表）
2.方法區中靜態屬性引用的對象
3. 方法區中常量引用的對象
4.本地方法棧中引用的對象（Native對象）
2.2tracing算法的示意圖
2.3標記-清除算法分析
標記-清除算法採用從根集合進行掃描，對存活的對象對象標記，標記完畢後，再掃描整個空間中未被標記的對象，進行回收，如上圖所示。標記-清除算法不需要進行對象的移動，並且僅對不存活的對象進行處理，在存活對象比較多的情況下極為高效，但由於標記-清除算法直接回收不存活的對象，因此會造成內存碎片。
3.compacting算法 或 標記-整理算法
標記-整理算法採用標記-清除算法一樣的方式進行對象的標記，但在清除時不同，在回收不存活的對象佔用的空間後，會將所有的存活對象往左端空閒空間移動，並更新對應的指針。標記-整理算法是在標記-清除算法的基礎上，又進行了對象的移動，因此成本更高，但是卻解決了內存碎片的問題。在基於Compacting算法的收集器的實現中，一般增加句柄和句柄表。
4.copying算法(Compacting Collector)
該算法的提出是為了克服句柄的開銷和解決堆碎片的垃圾回收。它開始時把堆分成 一個對象 面和多個空閒面， 程序從對象面為對象分配空間，當對象滿了，基於copying算法的垃圾 收集就從根集中掃描活動對象，並將每個 活動對象複製到空閒面(使得活動對象所佔的內存之間沒有空閒洞)，這樣空閒面變成了對象面，原來的對象面變成了空閒面，程序會在新的對象面中分配內存。一種典型的基於coping算法的垃圾回收是stop-and-copy算法，它將堆分成對象面和空閒區域面，在對象面與空閒區域面的切換過程中，程序暫停執行。
5.generation算法(Generational Collector)
一：垃圾回收機制的意義
java 語言中一個顯著的特點就是引入了java回收機制，是c++程序員最頭疼的內存管理的問題迎刃而解，它使得java程序員在編寫程序的時候不在考慮內存管理。由於有個垃圾回收機制，java中的額對象不在有“作用域”的概念，只有對象的引用才有“作用域”。垃圾回收可以有效的防止內存洩露，有效的使用空閒的內存；
內存洩露：指該內存空間使用完畢後未回收，在不涉及複雜數據結構的一般情況下，java的內存洩露表現為一個內存對象的生命週期超出了程序需要它的時間長度，我們有是也將其稱為“對象遊離”；
二：垃圾回收機制的算法
java語言規範沒有明確的說明JVM 使用哪種垃圾回收算法，但是任何一種垃圾回收算法一般要做兩件基本事情：（1）發現無用的信息對象；（2）回收將無用對象佔用的內存空間。使該空間可被程序再次使用。
1。引用計數法（Reference Counting Collector）
1.1:算法分析：
引用計數算法是垃圾回收器中的早起策略，在這種方法中，堆中的每個對象實例都有一個引用計數器，點一個對象被創建時，且該對象實例分配給一個變量，該變量計數設置為1 ，當任何其他變量賦值為這個對象的引用時，計數加1 ，（a=b ，則b引用的對象實例計數器+1）但當一個對象實例的某個引用超過了生命週期或者被設置為一個新值時，對象實例的引用計數器減1，任何引用計數器為0 的對象實例可以當做垃圾收集。 當一個對象的實例被垃圾收集是，它引用的任何對象實例的引用計數器減1.
一、垃圾回收機制的意義
Java語言中一個顯著的特點就是引入了垃圾回收機制，使c++程序員最頭疼的內存管理的問題迎刃而解，它使得Java程序員在編寫程序的時候不再需要考慮內存管理。由於有個垃圾回收機制，Java中的對象不再有“作用域”的概念，只有對象的引用才有“作用域”。垃圾回收可以有效的防止內存洩露，有效的使用空閒的內存。
ps:內存洩露是指該內存空間使用完畢之後未回收，在不涉及複雜數據結構的一般情況下，Java 的內存洩露表現為一個內存對象的生命週期超出了程序需要它的時間長度，我們有時也將其稱為“對象遊離”。
二、垃圾回收機制中的算法
Java語言規範沒有明確地說明JVM使用哪種垃圾回收算法，但是任何一種垃圾回收算法一般要做2件基本的事情：（1）發現無用信息對象；（2）回收被無用對象佔用的內存空間，使該空間可被程序再次使用。
1.引用計數法(Reference Counting Collector)
1.1算法分析
引用計數是垃圾收集器中的早期策略。在這種方法中，堆中每個對象實例都有一個引用計數。當一個對象被創建時，且將該對象實例分配給一個變量，該變量計數設置為1。當任何其它變量被賦值為這個對象的引用時，計數加1（a = b,則b引用的對象實例的計數器+1），但當一個對象實例的某個引用超過了生命週期或者被設置為一個新值時，對象實例的引用計數器減1。任何引用計數器為0的對象實例可以被當作垃圾收集。當一個對象實例被垃圾收集時，它引用的任何對象實例的引用計數器減1。
1.2優缺點
優點：
引用計數收集器可以很快的執行，交織在程序運行中。對程序需要不被長時間打斷的實時環境比較有利。
缺點：
無法檢測出循環引用。如父對象有一個對子對象的引用，子對象反過來引用父對象。這樣，他們的引用計數永遠不可能為0.
1.3引用計數算法無法解決循環引用問題，例如：
ublic class Main {
public static void main(String[] args) {
MyObject object1 = new MyObject();
MyObject object2 = new MyObject();
object1.object = object2;
object2.object = object1;
object1 = null;
object2 = null;
}
}
最後面兩句將object1和object2賦值為null，也就是說object1和object2指向的對象已經不可能再被訪問，但是由於它們互相引用對方，導致它們的引用計數器都不為0，那麼垃圾收集器就永遠不會回收它們。
2.tracing算法(Tracing Collector) 或 標記-清除算法(mark and sweep)
2.1根搜索算法
根搜索算法是從離散數學中的圖論引入的，程序把所有的引用關係看作一張圖，從一個節點GC ROOT開始，尋找對應的引用節點，找到這個節點以後，繼續尋找這個節點的引用節點，當所有的引用節點尋找完畢之後，剩餘的節點則被認為是沒有被引用到的節點，即無用的節點。
java中可作為GC Root的對象有
1.虛擬機棧中引用的對象（本地變量表）
2.方法區中靜態屬性引用的對象
3. 方法區中常量引用的對象
4.本地方法棧中引用的對象（Native對象）
2.2tracing算法的示意圖
2.3標記-清除算法分析
標記-清除算法採用從根集合進行掃描，對存活的對象對象標記，標記完畢後，再掃描整個空間中未被標記的對象，進行回收，如上圖所示。標記-清除算法不需要進行對象的移動，並且僅對不存活的對象進行處理，在存活對象比較多的情況下極為高效，但由於標記-清除算法直接回收不存活的對象，因此會造成內存碎片。
3.compacting算法 或 標記-整理算法
標記-整理算法採用標記-清除算法一樣的方式進行對象的標記，但在清除時不同，在回收不存活的對象佔用的空間後，會將所有的存活對象往左端空閒空間移動，並更新對應的指針。標記-整理算法是在標記-清除算法的基礎上，又進行了對象的移動，因此成本更高，但是卻解決了內存碎片的問題。在基於Compacting算法的收集器的實現中，一般增加句柄和句柄表。
4.copying算法(Compacting Collector)
該算法的提出是為了克服句柄的開銷和解決堆碎片的垃圾回收。它開始時把堆分成 一個對象 面和多個空閒面， 程序從對象面為對象分配空間，當對象滿了，基於copying算法的垃圾 收集就從根集中掃描活動對象，並將每個 活動對象複製到空閒面(使得活動對象所佔的內存之間沒有空閒洞)，這樣空閒面變成了對象面，原來的對象面變成了空閒面，程序會在新的對象面中分配內存。一種典型的基於coping算法的垃圾回收是stop-and-copy算法，它將堆分成對象面和空閒區域面，在對象面與空閒區域面的切換過程中，程序暫停執行。
5.generation算法(Generational Collector)
分代的垃圾回收策略，是基於這樣一個事實：不同的對象的生命週期是不一樣的。因此，不同生命週期的對象可以採取不同的回收算法，以便提高回收效率。
年輕代（Young Generation）
1.所有新生成的對象首先都是放在年輕代的。年輕代的目標就是儘可能快速的收集掉那些生命週期短的對象。
2.新生代內存按照8:1:1的比例分為一個eden區和兩個survivor(survivor0,survivor1)區。一個Eden區，兩個 Survivor區(一般而言)。大部分對象在Eden區中生成。回收時先將eden區存活對象複製到一個survivor0區，然後清空eden區，當這個survivor0區也存放滿了時，則將eden區和survivor0區存活對象複製到另一個survivor1區，然後清空eden和這個survivor0區，此時survivor0區是空的，然後將survivor0區和survivor1區交換，即保持survivor1區為空， 如此往復。
3.當survivor1區不足以存放 eden和survivor0的存活對象時，就將存活對象直接存放到老年代。若是老年代也滿了就會觸發一次Full GC，也就是新生代、老年代都進行回收
4.新生代發生的GC也叫做Minor GC，MinorGC發生頻率比較高(不一定等Eden區滿了才觸發)
年老代（Old Generation）
1.在年輕代中經歷了N次垃圾回收後仍然存活的對象，就會被放到年老代中。因此，可以認為年老代中存放的都是一些生命週期較長的對象。
2.內存比新生代也大很多(大概比例是1:2)，當老年代內存滿時觸發Major GC即Full GC，Full GC發生頻率比較低，老年代對象存活時間比較長，存活率標記高。
持久代（Permanent Generation）
用於存放靜態文件，如Java類、方法等。持久代對垃圾回收沒有顯著影響，但是有些應用可能動態生成或者調用一些class，例如Hibernate 等，在這種時候需要設置一個比較大的持久代空間來存放這些運行過程中新增的類。
三.GC（垃圾收集器）
新生代收集器使用的收集器：Serial、PraNew、Parallel Scavenge
老年代收集器使用的收集器：Serial Old、Parallel Old、CMS
一：垃圾回收機制的意義
java 語言中一個顯著的特點就是引入了java回收機制，是c++程序員最頭疼的內存管理的問題迎刃而解，它使得java程序員在編寫程序的時候不在考慮內存管理。由於有個垃圾回收機制，java中的額對象不在有“作用域”的概念，只有對象的引用才有“作用域”。垃圾回收可以有效的防止內存洩露，有效的使用空閒的內存；
內存洩露：指該內存空間使用完畢後未回收，在不涉及複雜數據結構的一般情況下，java的內存洩露表現為一個內存對象的生命週期超出了程序需要它的時間長度，我們有是也將其稱為“對象遊離”；
二：垃圾回收機制的算法
java語言規範沒有明確的說明JVM 使用哪種垃圾回收算法，但是任何一種垃圾回收算法一般要做兩件基本事情：（1）發現無用的信息對象；（2）回收將無用對象佔用的內存空間。使該空間可被程序再次使用。
1。引用計數法（Reference Counting Collector）
1.1:算法分析：
引用計數算法是垃圾回收器中的早起策略，在這種方法中，堆中的每個對象實例都有一個引用計數器，點一個對象被創建時，且該對象實例分配給一個變量，該變量計數設置為1 ，當任何其他變量賦值為這個對象的引用時，計數加1 ，（a=b ，則b引用的對象實例計數器+1）但當一個對象實例的某個引用超過了生命週期或者被設置為一個新值時，對象實例的引用計數器減1，任何引用計數器為0 的對象實例可以當做垃圾收集。 當一個對象的實例被垃圾收集是，它引用的任何對象實例的引用計數器減1.
一、垃圾回收機制的意義
Java語言中一個顯著的特點就是引入了垃圾回收機制，使c++程序員最頭疼的內存管理的問題迎刃而解，它使得Java程序員在編寫程序的時候不再需要考慮內存管理。由於有個垃圾回收機制，Java中的對象不再有“作用域”的概念，只有對象的引用才有“作用域”。垃圾回收可以有效的防止內存洩露，有效的使用空閒的內存。
ps:內存洩露是指該內存空間使用完畢之後未回收，在不涉及複雜數據結構的一般情況下，Java 的內存洩露表現為一個內存對象的生命週期超出了程序需要它的時間長度，我們有時也將其稱為“對象遊離”。
二、垃圾回收機制中的算法
Java語言規範沒有明確地說明JVM使用哪種垃圾回收算法，但是任何一種垃圾回收算法一般要做2件基本的事情：（1）發現無用信息對象；（2）回收被無用對象佔用的內存空間，使該空間可被程序再次使用。
1.引用計數法(Reference Counting Collector)
1.1算法分析
引用計數是垃圾收集器中的早期策略。在這種方法中，堆中每個對象實例都有一個引用計數。當一個對象被創建時，且將該對象實例分配給一個變量，該變量計數設置為1。當任何其它變量被賦值為這個對象的引用時，計數加1（a = b,則b引用的對象實例的計數器+1），但當一個對象實例的某個引用超過了生命週期或者被設置為一個新值時，對象實例的引用計數器減1。任何引用計數器為0的對象實例可以被當作垃圾收集。當一個對象實例被垃圾收集時，它引用的任何對象實例的引用計數器減1。
1.2優缺點
優點：
引用計數收集器可以很快的執行，交織在程序運行中。對程序需要不被長時間打斷的實時環境比較有利。
缺點：
無法檢測出循環引用。如父對象有一個對子對象的引用，子對象反過來引用父對象。這樣，他們的引用計數永遠不可能為0.
1.3引用計數算法無法解決循環引用問題，例如：
ublic class Main {
public static void main(String[] args) {
MyObject object1 = new MyObject();
MyObject object2 = new MyObject();
object1.object = object2;
object2.object = object1;
object1 = null;
object2 = null;
}
}
最後面兩句將object1和object2賦值為null，也就是說object1和object2指向的對象已經不可能再被訪問，但是由於它們互相引用對方，導致它們的引用計數器都不為0，那麼垃圾收集器就永遠不會回收它們。
2.tracing算法(Tracing Collector) 或 標記-清除算法(mark and sweep)
2.1根搜索算法
根搜索算法是從離散數學中的圖論引入的，程序把所有的引用關係看作一張圖，從一個節點GC ROOT開始，尋找對應的引用節點，找到這個節點以後，繼續尋找這個節點的引用節點，當所有的引用節點尋找完畢之後，剩餘的節點則被認為是沒有被引用到的節點，即無用的節點。
java中可作為GC Root的對象有
1.虛擬機棧中引用的對象（本地變量表）
2.方法區中靜態屬性引用的對象
3. 方法區中常量引用的對象
4.本地方法棧中引用的對象（Native對象）
2.2tracing算法的示意圖
2.3標記-清除算法分析
標記-清除算法採用從根集合進行掃描，對存活的對象對象標記，標記完畢後，再掃描整個空間中未被標記的對象，進行回收，如上圖所示。標記-清除算法不需要進行對象的移動，並且僅對不存活的對象進行處理，在存活對象比較多的情況下極為高效，但由於標記-清除算法直接回收不存活的對象，因此會造成內存碎片。
3.compacting算法 或 標記-整理算法
標記-整理算法採用標記-清除算法一樣的方式進行對象的標記，但在清除時不同，在回收不存活的對象佔用的空間後，會將所有的存活對象往左端空閒空間移動，並更新對應的指針。標記-整理算法是在標記-清除算法的基礎上，又進行了對象的移動，因此成本更高，但是卻解決了內存碎片的問題。在基於Compacting算法的收集器的實現中，一般增加句柄和句柄表。
4.copying算法(Compacting Collector)
該算法的提出是為了克服句柄的開銷和解決堆碎片的垃圾回收。它開始時把堆分成 一個對象 面和多個空閒面， 程序從對象面為對象分配空間，當對象滿了，基於copying算法的垃圾 收集就從根集中掃描活動對象，並將每個 活動對象複製到空閒面(使得活動對象所佔的內存之間沒有空閒洞)，這樣空閒面變成了對象面，原來的對象面變成了空閒面，程序會在新的對象面中分配內存。一種典型的基於coping算法的垃圾回收是stop-and-copy算法，它將堆分成對象面和空閒區域面，在對象面與空閒區域面的切換過程中，程序暫停執行。
5.generation算法(Generational Collector)
分代的垃圾回收策略，是基於這樣一個事實：不同的對象的生命週期是不一樣的。因此，不同生命週期的對象可以採取不同的回收算法，以便提高回收效率。
年輕代（Young Generation）
1.所有新生成的對象首先都是放在年輕代的。年輕代的目標就是儘可能快速的收集掉那些生命週期短的對象。
2.新生代內存按照8:1:1的比例分為一個eden區和兩個survivor(survivor0,survivor1)區。一個Eden區，兩個 Survivor區(一般而言)。大部分對象在Eden區中生成。回收時先將eden區存活對象複製到一個survivor0區，然後清空eden區，當這個survivor0區也存放滿了時，則將eden區和survivor0區存活對象複製到另一個survivor1區，然後清空eden和這個survivor0區，此時survivor0區是空的，然後將survivor0區和survivor1區交換，即保持survivor1區為空， 如此往復。
3.當survivor1區不足以存放 eden和survivor0的存活對象時，就將存活對象直接存放到老年代。若是老年代也滿了就會觸發一次Full GC，也就是新生代、老年代都進行回收
4.新生代發生的GC也叫做Minor GC，MinorGC發生頻率比較高(不一定等Eden區滿了才觸發)
年老代（Old Generation）
1.在年輕代中經歷了N次垃圾回收後仍然存活的對象，就會被放到年老代中。因此，可以認為年老代中存放的都是一些生命週期較長的對象。
2.內存比新生代也大很多(大概比例是1:2)，當老年代內存滿時觸發Major GC即Full GC，Full GC發生頻率比較低，老年代對象存活時間比較長，存活率標記高。
持久代（Permanent Generation）
用於存放靜態文件，如Java類、方法等。持久代對垃圾回收沒有顯著影響，但是有些應用可能動態生成或者調用一些class，例如Hibernate 等，在這種時候需要設置一個比較大的持久代空間來存放這些運行過程中新增的類。
三.GC（垃圾收集器）
新生代收集器使用的收集器：Serial、PraNew、Parallel Scavenge
老年代收集器使用的收集器：Serial Old、Parallel Old、CMS
Serial收集器（複製算法)
新生代單線程收集器，標記和清理都是單線程，優點是簡單高效。
Serial Old收集器(標記-整理算法)
老年代單線程收集器，Serial收集器的老年代版本。
ParNew收集器(停止-複製算法)
新生代收集器，可以認為是Serial收集器的多線程版本,在多核CPU環境下有著比Serial更好的表現。
Parallel Scavenge收集器(停止-複製算法)
並行收集器，追求高吞吐量，高效利用CPU。吞吐量一般為99%， 吞吐量= 用戶線程時間/(用戶線程時間+GC線程時間)。適合後臺應用等對交互相應要求不高的場景。
Parallel Old收集器(停止-複製算法)
Parallel Scavenge收集器的老年代版本，並行收集器，吞吐量優先
CMS(Concurrent Mark Sweep)收集器（標記-清理算法）
高併發、低停頓，追求最短GC回收停頓時間，cpu佔用比較高，響應時間快，停頓時間短，多核cpu 追求高響應時間的選擇
四、GC的執行機制
由於對象進行了分代處理，因此垃圾回收區域、時間也不一樣。GC有兩種類型：Scavenge GC和Full GC。
Scavenge GC
一般情況下，當新對象生成，並且在Eden申請空間失敗時，就會觸發Scavenge GC，對Eden區域進行GC，清除非存活對象，並且把尚且存活的對象移動到Survivor區。然後整理Survivor的兩個區。這種方式的GC是對年輕代的Eden區進行，不會影響到年老代。因為大部分對象都是從Eden區開始的，同時Eden區不會分配的很大，所以Eden區的GC會頻繁進行。因而，一般在這裡需要使用速度快、效率高的算法，使Eden去能儘快空閒出來。
Full GC
對整個堆進行整理，包括Young、Tenured和Perm。Full GC因為需要對整個堆進行回收，所以比Scavenge GC要慢，因此應該儘可能減少Full GC的次數。在對JVM調優的過程中，很大一部分工作就是對於FullGC的調節。有如下原因可能導致Full GC：
1.年老代（Tenured）被寫滿
2.持久代（Perm）被寫滿
3.System.gc()被顯示調用
4.上一次GC之後Heap的各域分配策略動態變化
五、Java有了GC同樣會出現內存洩露問題
1.靜態集合類像HashMap、Vector等的使用最容易出現內存洩露，這些靜態變量的生命週期和應用程序一致，所有的對象Object也不能被釋放，因為他們也將一直被Vector等應用著。
Static Vector v = new Vector();
for (int i = 1; i<100; i++)
{
Object o = new Object();
v.add(o);
o = null;
}
在這個例子中，代碼棧中存在Vector 對象的引用 v 和 Object 對象的引用 o 。在 For 循環中，我們不斷的生成新的對象，然後將其添加到 Vector 對象中，之後將 o 引用置空。問題是當 o 引用被置空後，如果發生 GC，我們創建的 Object 對象是否能夠被 GC 回收呢？答案是否定的。因為， GC 在跟蹤代碼棧中的引用時，會發現 v 引用，而繼續往下跟蹤，就會發現 v 引用指向的內存空間中又存在指向 Object 對象的引用。也就是說盡管o 引用已經被置空，但是 Object 對象仍然存在其他的引用，是可以被訪問到的，所以 GC 無法將其釋放掉。如果在此循環之後， Object 對象對程序已經沒有任何作用，那麼我們就認為此 Java 程序發生了內存洩漏。
2.各種連接，數據庫連接，網絡連接，IO連接等沒有顯示調用close關閉，不被GC回收導致內存洩露。
3.監聽器的使用，在釋放對象的同時沒有相應刪除監聽器的時候也可能導致內存洩露。
一：垃圾回收機制的意義
java 語言中一個顯著的特點就是引入了java回收機制，是c++程序員最頭疼的內存管理的問題迎刃而解，它使得java程序員在編寫程序的時候不在考慮內存管理。由於有個垃圾回收機制，java中的額對象不在有“作用域”的概念，只有對象的引用才有“作用域”。垃圾回收可以有效的防止內存洩露，有效的使用空閒的內存；
內存洩露：指該內存空間使用完畢後未回收，在不涉及複雜數據結構的一般情況下，java的內存洩露表現為一個內存對象的生命週期超出了程序需要它的時間長度，我們有是也將其稱為“對象遊離”；
二：垃圾回收機制的算法
java語言規範沒有明確的說明JVM 使用哪種垃圾回收算法，但是任何一種垃圾回收算法一般要做兩件基本事情：（1）發現無用的信息對象；（2）回收將無用對象佔用的內存空間。使該空間可被程序再次使用。
1。引用計數法（Reference Counting Collector）
1.1:算法分析：
引用計數算法是垃圾回收器中的早起策略，在這種方法中，堆中的每個對象實例都有一個引用計數器，點一個對象被創建時，且該對象實例分配給一個變量，該變量計數設置為1 ，當任何其他變量賦值為這個對象的引用時，計數加1 ，（a=b ，則b引用的對象實例計數器+1）但當一個對象實例的某個引用超過了生命週期或者被設置為一個新值時，對象實例的引用計數器減1，任何引用計數器為0 的對象實例可以當做垃圾收集。 當一個對象的實例被垃圾收集是，它引用的任何對象實例的引用計數器減1.
一、垃圾回收機制的意義
Java語言中一個顯著的特點就是引入了垃圾回收機制，使c++程序員最頭疼的內存管理的問題迎刃而解，它使得Java程序員在編寫程序的時候不再需要考慮內存管理。由於有個垃圾回收機制，Java中的對象不再有“作用域”的概念，只有對象的引用才有“作用域”。垃圾回收可以有效的防止內存洩露，有效的使用空閒的內存。
ps:內存洩露是指該內存空間使用完畢之後未回收，在不涉及複雜數據結構的一般情況下，Java 的內存洩露表現為一個內存對象的生命週期超出了程序需要它的時間長度，我們有時也將其稱為“對象遊離”。
二、垃圾回收機制中的算法
Java語言規範沒有明確地說明JVM使用哪種垃圾回收算法，但是任何一種垃圾回收算法一般要做2件基本的事情：（1）發現無用信息對象；（2）回收被無用對象佔用的內存空間，使該空間可被程序再次使用。
1.引用計數法(Reference Counting Collector)
1.1算法分析
引用計數是垃圾收集器中的早期策略。在這種方法中，堆中每個對象實例都有一個引用計數。當一個對象被創建時，且將該對象實例分配給一個變量，該變量計數設置為1。當任何其它變量被賦值為這個對象的引用時，計數加1（a = b,則b引用的對象實例的計數器+1），但當一個對象實例的某個引用超過了生命週期或者被設置為一個新值時，對象實例的引用計數器減1。任何引用計數器為0的對象實例可以被當作垃圾收集。當一個對象實例被垃圾收集時，它引用的任何對象實例的引用計數器減1。
1.2優缺點
優點：
引用計數收集器可以很快的執行，交織在程序運行中。對程序需要不被長時間打斷的實時環境比較有利。
缺點：
無法檢測出循環引用。如父對象有一個對子對象的引用，子對象反過來引用父對象。這樣，他們的引用計數永遠不可能為0.
1.3引用計數算法無法解決循環引用問題，例如：
ublic class Main {
public static void main(String[] args) {
MyObject object1 = new MyObject();
MyObject object2 = new MyObject();
object1.object = object2;
object2.object = object1;
object1 = null;
object2 = null;
}
}
最後面兩句將object1和object2賦值為null，也就是說object1和object2指向的對象已經不可能再被訪問，但是由於它們互相引用對方，導致它們的引用計數器都不為0，那麼垃圾收集器就永遠不會回收它們。
2.tracing算法(Tracing Collector) 或 標記-清除算法(mark and sweep)
2.1根搜索算法
根搜索算法是從離散數學中的圖論引入的，程序把所有的引用關係看作一張圖，從一個節點GC ROOT開始，尋找對應的引用節點，找到這個節點以後，繼續尋找這個節點的引用節點，當所有的引用節點尋找完畢之後，剩餘的節點則被認為是沒有被引用到的節點，即無用的節點。
java中可作為GC Root的對象有
1.虛擬機棧中引用的對象（本地變量表）
2.方法區中靜態屬性引用的對象
3. 方法區中常量引用的對象
4.本地方法棧中引用的對象（Native對象）
2.2tracing算法的示意圖
2.3標記-清除算法分析
標記-清除算法採用從根集合進行掃描，對存活的對象對象標記，標記完畢後，再掃描整個空間中未被標記的對象，進行回收，如上圖所示。標記-清除算法不需要進行對象的移動，並且僅對不存活的對象進行處理，在存活對象比較多的情況下極為高效，但由於標記-清除算法直接回收不存活的對象，因此會造成內存碎片。
3.compacting算法 或 標記-整理算法
標記-整理算法採用標記-清除算法一樣的方式進行對象的標記，但在清除時不同，在回收不存活的對象佔用的空間後，會將所有的存活對象往左端空閒空間移動，並更新對應的指針。標記-整理算法是在標記-清除算法的基礎上，又進行了對象的移動，因此成本更高，但是卻解決了內存碎片的問題。在基於Compacting算法的收集器的實現中，一般增加句柄和句柄表。
4.copying算法(Compacting Collector)
該算法的提出是為了克服句柄的開銷和解決堆碎片的垃圾回收。它開始時把堆分成 一個對象 面和多個空閒面， 程序從對象面為對象分配空間，當對象滿了，基於copying算法的垃圾 收集就從根集中掃描活動對象，並將每個 活動對象複製到空閒面(使得活動對象所佔的內存之間沒有空閒洞)，這樣空閒面變成了對象面，原來的對象面變成了空閒面，程序會在新的對象面中分配內存。一種典型的基於coping算法的垃圾回收是stop-and-copy算法，它將堆分成對象面和空閒區域面，在對象面與空閒區域面的切換過程中，程序暫停執行。
5.generation算法(Generational Collector)
分代的垃圾回收策略，是基於這樣一個事實：不同的對象的生命週期是不一樣的。因此，不同生命週期的對象可以採取不同的回收算法，以便提高回收效率。
年輕代（Young Generation）
1.所有新生成的對象首先都是放在年輕代的。年輕代的目標就是儘可能快速的收集掉那些生命週期短的對象。
2.新生代內存按照8:1:1的比例分為一個eden區和兩個survivor(survivor0,survivor1)區。一個Eden區，兩個 Survivor區(一般而言)。大部分對象在Eden區中生成。回收時先將eden區存活對象複製到一個survivor0區，然後清空eden區，當這個survivor0區也存放滿了時，則將eden區和survivor0區存活對象複製到另一個survivor1區，然後清空eden和這個survivor0區，此時survivor0區是空的，然後將survivor0區和survivor1區交換，即保持survivor1區為空， 如此往復。
3.當survivor1區不足以存放 eden和survivor0的存活對象時，就將存活對象直接存放到老年代。若是老年代也滿了就會觸發一次Full GC，也就是新生代、老年代都進行回收
4.新生代發生的GC也叫做Minor GC，MinorGC發生頻率比較高(不一定等Eden區滿了才觸發)
年老代（Old Generation）
1.在年輕代中經歷了N次垃圾回收後仍然存活的對象，就會被放到年老代中。因此，可以認為年老代中存放的都是一些生命週期較長的對象。
2.內存比新生代也大很多(大概比例是1:2)，當老年代內存滿時觸發Major GC即Full GC，Full GC發生頻率比較低，老年代對象存活時間比較長，存活率標記高。
持久代（Permanent Generation）
用於存放靜態文件，如Java類、方法等。持久代對垃圾回收沒有顯著影響，但是有些應用可能動態生成或者調用一些class，例如Hibernate 等，在這種時候需要設置一個比較大的持久代空間來存放這些運行過程中新增的類。
三.GC（垃圾收集器）
新生代收集器使用的收集器：Serial、PraNew、Parallel Scavenge
老年代收集器使用的收集器：Serial Old、Parallel Old、CMS
Serial收集器（複製算法)
新生代單線程收集器，標記和清理都是單線程，優點是簡單高效。
Serial Old收集器(標記-整理算法)
老年代單線程收集器，Serial收集器的老年代版本。
ParNew收集器(停止-複製算法)
新生代收集器，可以認為是Serial收集器的多線程版本,在多核CPU環境下有著比Serial更好的表現。
Parallel Scavenge收集器(停止-複製算法)
並行收集器，追求高吞吐量，高效利用CPU。吞吐量一般為99%， 吞吐量= 用戶線程時間/(用戶線程時間+GC線程時間)。適合後臺應用等對交互相應要求不高的場景。
Parallel Old收集器(停止-複製算法)
Parallel Scavenge收集器的老年代版本，並行收集器，吞吐量優先
CMS(Concurrent Mark Sweep)收集器（標記-清理算法）
高併發、低停頓，追求最短GC回收停頓時間，cpu佔用比較高，響應時間快，停頓時間短，多核cpu 追求高響應時間的選擇
四、GC的執行機制
由於對象進行了分代處理，因此垃圾回收區域、時間也不一樣。GC有兩種類型：Scavenge GC和Full GC。
Scavenge GC
一般情況下，當新對象生成，並且在Eden申請空間失敗時，就會觸發Scavenge GC，對Eden區域進行GC，清除非存活對象，並且把尚且存活的對象移動到Survivor區。然後整理Survivor的兩個區。這種方式的GC是對年輕代的Eden區進行，不會影響到年老代。因為大部分對象都是從Eden區開始的，同時Eden區不會分配的很大，所以Eden區的GC會頻繁進行。因而，一般在這裡需要使用速度快、效率高的算法，使Eden去能儘快空閒出來。
Full GC
對整個堆進行整理，包括Young、Tenured和Perm。Full GC因為需要對整個堆進行回收，所以比Scavenge GC要慢，因此應該儘可能減少Full GC的次數。在對JVM調優的過程中，很大一部分工作就是對於FullGC的調節。有如下原因可能導致Full GC：
1.年老代（Tenured）被寫滿
2.持久代（Perm）被寫滿
3.System.gc()被顯示調用
4.上一次GC之後Heap的各域分配策略動態變化
五、Java有了GC同樣會出現內存洩露問題
1.靜態集合類像HashMap、Vector等的使用最容易出現內存洩露，這些靜態變量的生命週期和應用程序一致，所有的對象Object也不能被釋放，因為他們也將一直被Vector等應用著。
Static Vector v = new Vector();
for (int i = 1; i<100; i++)
{
Object o = new Object();
v.add(o);
o = null;
}
在這個例子中，代碼棧中存在Vector 對象的引用 v 和 Object 對象的引用 o 。在 For 循環中，我們不斷的生成新的對象，然後將其添加到 Vector 對象中，之後將 o 引用置空。問題是當 o 引用被置空後，如果發生 GC，我們創建的 Object 對象是否能夠被 GC 回收呢？答案是否定的。因為， GC 在跟蹤代碼棧中的引用時，會發現 v 引用，而繼續往下跟蹤，就會發現 v 引用指向的內存空間中又存在指向 Object 對象的引用。也就是說盡管o 引用已經被置空，但是 Object 對象仍然存在其他的引用，是可以被訪問到的，所以 GC 無法將其釋放掉。如果在此循環之後， Object 對象對程序已經沒有任何作用，那麼我們就認為此 Java 程序發生了內存洩漏。
2.各種連接，數據庫連接，網絡連接，IO連接等沒有顯示調用close關閉，不被GC回收導致內存洩露。
3.監聽器的使用，在釋放對象的同時沒有相應刪除監聽器的時候也可能導致內存洩露。