1.背景

Java語言相比于C和C++，一個最大的特點就是不需要程序員自己手動去申請和釋放內(nèi)存，這一切交由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已經(jīng)沒人使用他們了，這就造成了內(nèi)存泄漏。所以，引用計數(shù)法雖然實現(xiàn)簡單，但并不是一個完美的解決方案，實際中的Java也沒有采用它。

2.2 可達(dá)性分析算法

主要思想是：首先確定確定一系列肯定不能被回收的對象，即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命令，生成堆轉(zhuǎn)儲快照dump文件，其中2872是進程id，可以使用jps命令查看。然后使用MAT工具打開dump文件，可以很明顯地看到一共有四類對象可以作為GC Roots，下面詳細(xì)介紹下。

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

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

第三類，活動線程中正在引用的對象?？梢钥闯?，代碼中變量o指向的Object對象可以被當(dāng)作GC Roots。

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

3.Java中的幾種引用

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

3.1強引用

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

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();
 }

對于軟引用指向的對象，當(dāng)內(nèi)存不夠用時，該對象就會被回收。為演示這個現(xiàn)象，將JVM的堆內(nèi)存設(shè)置為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());
  }
 }
}

上述代碼在堆內(nèi)存為10M的情況下運行的結(jié)果如下圖。可以看到前三個軟引用指向的對象已經(jīng)被垃圾回收器回收掉了，原因就是堆內(nèi)存不夠用了，軟引用指向的對象就被回收了。

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

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++) {
   // 同時將軟引用關(guān)聯(lián)引用隊列，當(dāng)軟引用指向的對象被回收時，該軟引用會加入到隊列
   SoftReference<Object> softReference = new SoftReference<>(new byte[_2M], queue);
   list.add(softReference);
  }
 
  // 移除List中，指向?qū)ο笠呀?jīng)被回收的軟引用
  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í)行結(jié)果如下：

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());
  }
 }
}

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

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

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)此時弱引用指向的對象都被回收掉了。和軟引用一樣，弱引用也可以結(jié)合引用隊列使用，這里不再贅述。

3.4虛引用

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

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

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

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

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

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

當(dāng)DirectByteBuffer對象被回收后，Cleaner對象會被加入引用隊列

這時ReferenceHandler線程會調(diào)用Cleaner對象的clean方法完成對堆外內(nèi)存的回收

clean方法會調(diào)用Deallocator的run方法，通過Unsafe類最終完成堆外內(nèi)存的回收

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

4.總結(jié)

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

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

最新評論