1.背景

Java語言相比于C和C++，一個最大的特點就是不需要程序員自己手動去申請和釋放內存，這一切交由JVM來完成。在Java中，運行時的數(shù)據(jù)區(qū)域分為程序計數(shù)器、Java虛擬機棧、本地方法棧、方法區(qū)和堆。其中，程序計數(shù)器、虛擬機棧和本地方法棧是線程私有的，線程銷毀后自動釋放。垃圾回收的行為發(fā)生在堆和方法區(qū)，主要是堆，而堆中存儲的主要是對象。那么自然而然地就會有這么幾個問題，哪些對象可以被回收？通過什么方式回收？本文主要探討第一個問題，以及JVM對Java中幾種引用的回收策略。

2.如何判斷一個對象是否可以被回收

2.1 引用計數(shù)法

主要思想是：給對象添加一個引用計數(shù)器，這個對象被引用一次，計數(shù)器就加1；不再引用了，計數(shù)器就減1。如果一個對象的引用計數(shù)器為0，說明沒有人使用這個對象，那么這個對象就可以被回收了。這種方法實現(xiàn)起來比較簡單，效率也比較高，大多數(shù)情況下都是有效的。但是，這種方法有一個漏洞。比如A.property = B，B.property = A，A和B兩個對象互相引用，并且沒有其他對象引用A和B。按照引用計數(shù)法的思想，A和B對象的引用計數(shù)器都不為0，都不能被釋放，但實際情況是A和B已經沒人使用他們了，這就造成了內存泄漏。所以，引用計數(shù)法雖然實現(xiàn)簡單，但并不是一個完美的解決方案，實際中的Java也沒有采用它。

2.2 可達性分析算法

主要思想是：首先確定確定一系列肯定不能被回收的對象，即GC Roots。然后，從這些GC Roots出發(fā)，向下搜索，去尋找它直接和間接引用的對象。最后，如果一個對象沒有被GC Roots直接或間接地引用，那么這個對象就可以被回收了。這種方法可以有效解決循環(huán)引用的問題，實際中Java也是采用這種判斷方法。那么問題來了，哪些對象可以作為GC Roots呢？這里可以使用MAT工具進行觀察。運行下面的demo：

import java.util.concurrent.TimeUnit;
 
public class GCRootsTest {
 public static void main(String[] args) throws InterruptedException {
  Object o = new Object();
  TimeUnit.SECONDS.sleep(100);
 }
}

主線程sleep的時候，在terminal窗口執(zhí)行jmap -dump:format=b,live,file=heapdump.bin 2872命令，生成堆轉儲快照dump文件，其中2872是進程id，可以使用jps命令查看。然后使用MAT工具打開dump文件，可以很明顯地看到一共有四類對象可以作為GC Roots，下面詳細介紹下。

第一類，系統(tǒng)類對象（System Class）。比如，java.lang.String的Class對象，這個也很好理解，如果這些核心的系統(tǒng)類對象被回收了，程序就沒辦法運行了。

第二類，native方法引用的對象。

第三類，活動線程中正在引用的對象?？梢钥闯觯a中變量o指向的Object對象可以被當作GC Roots。

第四類，正在加鎖的對象。

3.Java中的幾種引用

在可達性分析算法中，判斷一個對象是不是可以被回收，主要看從GC Roots出發(fā)是否可以找到一個引用指向該對象。java中的引用一共有四種，按照引用的強弱依次為強引用（Strong Reference）、軟引用（Soft Reference）、弱引用（Weak Reference）、虛引用（Phantom Reference）。這樣就可以對不同引用指向的對象采取不同的回收策略。比如一個強引用指向一個對象，那么這個對象肯定不會被回收，哪怕發(fā)生OOM。而對于弱引用指向的對象，只要發(fā)生垃圾回收，該對象就會被回收。下面詳細介紹下不同引用的用法。

3.1強引用

所謂強引用，就是平時使用最多的，類似于Object obj = new Object()的引用。垃圾回收器永遠不會回收被強引用指向的對象。

3.2軟引用

軟引用，在Java中使用SoftReference類來實現(xiàn)軟引用。在下面的代碼中，softReference作為軟用指向一個Object對象，而otherObject變量可以通過軟引用的get方法間接引用到Object對象。

 public static void main(String[] args) {
  // 軟引用
  SoftReference<Object> softReference = new SoftReference<>(new Object());
  Object otherObject = softReference.get();
 }

對于軟引用指向的對象，當內存不夠用時，該對象就會被回收。為演示這個現(xiàn)象，將JVM的堆內存設置為10M（-Xms10M -Xmx10M）。以下代碼的主要邏輯是：向一個List集合中添加5個SoftReference對象，其中每個SoftReference對象都指向了一個大小為2M的byte數(shù)組，添加完成之后遍歷List，并打印List中每一個軟引用指向的對象。

public class ReferenceTest {
 
 private static final int _2M = 2 * 1024 * 1024;
 
 public static void main(String[] args) {
  List<SoftReference<Object>> list = new ArrayList<>();
  for (int i = 0; i < 5; i++) {
   SoftReference<Object> softReference = new SoftReference<>(new byte[_2M]);
   list.add(softReference);
  }
 
  System.out.println("List集合中的軟引用：");
  for (int i = 0; i < 5; i++) {
   System.out.println(list.get(i));
  }
 
  System.out.println("--------------------------");
  System.out.println("List集合中的軟引用指向的對象：");
  for (int i = 0; i < 5; i++) {
   System.out.println(list.get(i).get());
  }
 }
}

上述代碼在堆內存為10M的情況下運行的結果如下圖?？梢钥吹角叭齻€軟引用指向的對象已經被垃圾回收器回收掉了，原因就是堆內存不夠用了，軟引用指向的對象就被回收了。

通常情況下，軟引用指向的對象被回收了，那么這個軟引用也就沒有存在的意義了，應該被垃圾回收器回收掉。為了實現(xiàn)這個效果，通常軟引用要配合引用隊列使用。用法如下面的代碼所示，將軟引用和引用隊列關聯(lián)，這樣當軟引用指向的對象被回收時，該軟引用會自動加入到引用隊列，這時候可以采用一定的策略將這些軟引用對象回收。

public class ReferenceTest {
 
 private static final int _2M = 2 * 1024 * 1024;
 
 public static void main(String[] args) {
  List<SoftReference<Object>> list = new ArrayList<>();
  // 引用隊列
  ReferenceQueue<Object> queue = new ReferenceQueue<>();
  for (int i = 0; i < 5; i++) {
   // 同時將軟引用關聯(lián)引用隊列，當軟引用指向的對象被回收時，該軟引用會加入到隊列
   SoftReference<Object> softReference = new SoftReference<>(new byte[_2M], queue);
   list.add(softReference);
  }
 
  // 移除List中，指向對象已經被回收的軟引用
  Reference<?> poll = queue.poll();
  while (null != poll) {
   list.remove(poll);
   poll = queue.poll();
  }
 
  System.out.println("List集合中的軟引用：");
  for (SoftReference<Object> reference : list) {
   System.out.println(reference);
  }
 
  System.out.println("-------------------------------------");
  System.out.println("List集合中的軟引用指向的對象：");
  for (SoftReference<Object> reference : list) {
   System.out.println(reference.get());
  }
 }
}

執(zhí)行結果如下：

3.3弱引用

弱引用，相比于軟引用，它的引用程度更弱。只要發(fā)生垃圾回收，弱引用指向的對象都會被回收。話不多說，直接上代碼。跟軟引用的demo差不多，唯一不同的是每個byte的數(shù)組的大小變成了2K，這樣堆肯定放的下，也不會發(fā)生垃圾回收。

public class WeakReferenceTest {
 private static final int _2K = 2 * 1024;
 
 public static void main(String[] args) {
  List<WeakReference<byte[]>> list = new ArrayList<>();
  for (int i = 0; i < 5; i++) {
   WeakReference<byte[]> reference = new WeakReference<>(new byte[_2K]);
   list.add(reference);
  }
 
  System.out.println("List集合中的軟引用：");
  for (WeakReference<byte[]> reference : list) {
   System.out.println(reference);
  }
 
  System.out.println("-------------------------------------");
  System.out.println("List集合中的軟引用指向的對象：");
  for (WeakReference<byte[]> reference: list) {
   System.out.println(reference.get());
  }
 }
}

運行?？梢钥吹饺跻弥赶虻膶ο蟛]有被回收。

在上述代碼的基礎上，人為的進行一次垃圾回收，代碼如下。

public class WeakReferenceTest {
 private static final int _2K = 2 * 1024;
 
 public static void main(String[] args) {
  List<WeakReference<byte[]>> list = new ArrayList<>();
  for (int i = 0; i < 5; i++) {
   WeakReference<byte[]> reference = new WeakReference<>(new byte[_2K]);
   list.add(reference);
  }
 
  System.gc(); // 手動垃圾回收
  System.out.println("List集合中的弱引用：");
  for (WeakReference<byte[]> reference : list) {
   System.out.println(reference);
  }
 
  System.out.println("-------------------------------------");
  System.out.println("List集合中的弱引用指向的對象：");
  for (WeakReference<byte[]> reference: list) {
   System.out.println(reference.get());
  }
 }
}

運行。發(fā)現(xiàn)此時弱引用指向的對象都被回收掉了。和軟引用一樣，弱引用也可以結合引用隊列使用，這里不再贅述。

3.4虛引用

與軟引用和虛引用不同，虛引用必須配合引用隊列使用，而且不能通過虛引用獲取到虛引用指向的對象。在Java中虛引用使用PhantomReference類來表示，從PhantomReference的源碼可以看出調用虛引用的get方法始終返回的是null，而且PhantomReference只提供了包含引用隊列的有參構造器，這也就是說虛引用必須結合引用隊列使用。

public class PhantomReference<T> extends Reference<T> {
 
 public T get() {
  return null;
 }
 
 public PhantomReference(T referent, ReferenceQueue<? super T> q) {
  super(referent, q);
 }
 
}

既然不能通過虛引用獲取到它指向的對象，那么虛引用到底有什么用呢？實際上，為一個對象關聯(lián)虛引用的唯一目的就是：在​該對象被垃圾回收時收到一個系統(tǒng)通知。當垃圾回收器準備回收一個對象時，如果發(fā)現(xiàn)還有虛引用與之關聯(lián)，就會在垃圾回收后，將這個虛引用加入引用隊列，在其關聯(lián)的虛引用出隊前，不會徹底銷毀該對象。 上面的描述還是不夠通俗易懂，其實虛引用的一個經典的使用場景就是和DirectByteBuffer類關聯(lián)使用。DirectByteBuffer類使用的是堆外內存（服務器內存中，除了JVM占用外的那部分），省去了數(shù)據(jù)到內核的拷貝，因此效率比ByteBuffer要高很多（這里的重點是虛引用，想要了解DirectByteBuffer類的底層原理，可以在網上找下資源），它的內存示意圖如下。

雖然DirectByteBuffer類的效率很高，但是由于堆外內存JVM的垃圾回收器不能進行回收，所以要謹慎處理DirectByteBuffer類使用的堆外內存，否則極易造成服務器內存泄漏。為了解決這個問題，虛引用就派上用場了。DirectByteBuffer類的創(chuàng)建和回收主要分為以下幾個步驟

創(chuàng)建DirecByteBuffer對象時會同時創(chuàng)建一個Cleaner虛引用對象，指向自己，同時傳一個Deallocator對象給Cleaner

 Cleaner類的父類是PhantomReference，爺爺類是Reference。Reference類在初始化的時候會啟動一個ReferenceHandler線程

當DirectByteBuffer對象被回收后，Cleaner對象會被加入引用隊列

這時ReferenceHandler線程會調用Cleaner對象的clean方法完成對堆外內存的回收

clean方法會調用Deallocator的run方法，通過Unsafe類最終完成堆外內存的回收

總結起來就是一句話，用虛引用關聯(lián)DirectByteBuffer對象，當DirectByteBuffer被回收后，虛引用對象會被加入到引用隊列，進而由該虛引用對象完成對堆外內存的釋放。（感興趣的或伙伴可以跟以下DirectByteBuffer的源碼）

4.總結

• JVM采用可達性分析算法來判斷堆中有哪些對象可以被回收。
• 主要有四類對象可作為GC Roots：系統(tǒng)類對象、Native方法引用的對象、活動線程引用的對象以及正在加鎖的對象。
• Java中常用的引用主要有四種，強引用、軟引用、弱引用和虛引用，對不同引用指向的對象，JVM有不同的回收策略。
• 對于強引用指向的對象，垃圾回收器不會將其回收，即使是發(fā)生OOM。
• 對于軟引用指向的對象，當內存不夠時，垃圾回收器會將其回收。這個特點可以用來實現(xiàn)緩存，當內存不足時JVM會自動清理掉這些緩存。
• 對于弱引用指向的對象，當發(fā)生垃圾回收時，垃圾回收器會將其回收。
• 對于虛引用，必須配合引用隊列使用，而且不能通過虛引用獲取到虛引用指向的對象，為一個對象關聯(lián)虛引用的唯一目的就是在​該對象被垃圾回收時收到一個系統(tǒng)通知。
  

到此這篇關于JVM垃圾回收之哪些對象可以被回收的文章就介紹到這了,更多相關JVM垃圾回收之哪些對象可以被回收內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！