[Java開發之路]（25）引用類型

[Java開發之路]（25）引用類型

1. 強引用

Java中的引用，類似於C++的指針。通過引用，可以對堆中的對象進行操作。在某個函數中，當創建了一個對象，該對象被分配在堆中，通過這個對象的引用才能對這個對象進行操作。

1. StringBuffer str = new StringBuffer("hello world");

假設以上代碼是在函數體內運行的，那麼局部變量str將被分配在棧上，而對象StringBuffer實例，被分配在堆上。局部變量str指向StringBuffer實例所在的堆空間，通過str可以操作該實例，那麼str就是StringBuffer的引用。

此時，運行一個賦值語句：

1. StringBuffer str1 = str;

那麼，str所指向的對象也將被str1所指向，同時在局部棧空間上會分配空間存放str1變量。此時，該StringBuffer實例就有兩個引用。對引用的"=="操作用於表示兩個操作數所指向的堆空間地址是否相同，不表示兩個操作數所指向的對象是否相等。

強引用特點：

強引用可以直接訪問目標對象。

強引用所指向的對象在任何時候都不會被系統回收。JVM寧願拋出OOM異常，也不會回收強引用所指向的對象。

強引用可能導致內存洩露。

2. 軟引用

軟引用是除了強引用外，最強的引用類型。可以通過java.lang.ref.SoftReference使用軟引用。一個持有軟引用的對象，不會被JVM很快回收，JVM會根據當前堆的使用情況來判斷何時回收。當堆的使用率臨近阈值時，才會回收軟引用的對象。

1. package com.qunar.base;
2. import java.lang.ref.Reference;
3. import java.lang.ref.ReferenceQueue;
4. import java.lang.ref.SoftReference;
5. /**
6. * Created by xiaosi on 16-3-24.
7. */
8. public class ReferenceDemo {
9. // 創建引用隊列
10. private ReferenceQueue referenceQueue = new ReferenceQueue<>();
11. public class MyObject {
12. @Override
13. protected void finalize() throws Throwable {
14. super.finalize();
15. // 被回收時輸出
16. System.out.println("MyObject is finalize called");
17. }
18. @Override
19. public String toString() {
20. return " I am MyObject";
21. }
22. }
23. public class CheckRefQueue implements Runnable {
24. Reference obj = null;
25. @Override
26. public void run() {
27. try {
28. // 如果對象被回收則進入引用隊列
29. obj = (Reference) referenceQueue.remove();
30. } catch (InterruptedException e) {
31. e.printStackTrace();
32. }
33. if (obj != null) {
34. System.out.println("Object for SoftReference is " + obj.get());
35. }
36. }
37. }
38. public void test() {
39. // 創建強引用
40. MyObject myObject = new MyObject();
41. // 構造myObject對象的軟引用 注冊到 引用隊列
42. SoftReference softReference = new SoftReference<>(myObject, referenceQueue);
43. CheckRefQueue checkRefQueue = new CheckRefQueue();
44. Thread thread = new Thread(checkRefQueue);
45. thread.start();
46. // 刪除強引用 對myObject對象的引用只剩下軟引用
47. myObject = null;
48. System.gc();
49. System.out.println("After GC: Soft Get = " + softReference.get());
50. System.out.println("分配大塊內存");
51. // 分配一塊強大的內存，強迫GC
52. byte[] b = new byte[5*1024*963];
53. System.out.println("After new byte[]:Soft Get = "+softReference.get());
54. System.gc();
55. }
56. public static void main(String[] args) {
57. ReferenceDemo referenceDemo = new ReferenceDemo();
58. referenceDemo.test();
59. }
60. }

首先構造MyObject對象，並將其賦值給myObject變量，構成強引用。然後使用SoftReference構造這個MyObject對象的軟引用softReference，並注冊到referenceQueue隊列中。當softReference被回收時，會被加入referenceQueue隊列。設置myObject=null，刪除這個強引用，因此，系統內對MyObject對象的引用只剩下軟引用。此時，顯示調用GC，通過軟引用的get()方法，取得MyObject對象實例的強引用，發現對象被未回收。這說明GC在內存充足的情況下，不會回收軟引用對象。

接著，請求一塊大的堆空間new byte[4*1024*925]，這個操作會使操作系統內存使用緊張，從而產生新一輪的GC。這次GC後，softReference.get()不再返回MyObject對象，而是返回null，說明在系統內存緊張的情況下，軟引用被回收。軟引用被回收時，會被加入到注冊的引用隊列中。

備注：

JVM參數：-Xmx5M

運行結果：

/opt/jdk1.7.0_40/bin/java-Xmx5M...

After GC: Soft Get = I am MyObject

分配大塊內存

After new byte[]:Soft Get = null

MyObject is finalize called

Object for SoftReference is null

3. 弱引用

弱引用是一種比軟引用較弱的引用類型。在系統GC時，只要發現弱引用，不管系統堆空間是否足夠，都會將對象進行回收。但是，由於垃圾回收器的線程通常優先級很低，因此，並一不定能很快的發現持有弱引用的對象。這種情況下，弱引用對象可以存在較長的一段時間。一旦一個弱引用對象被垃圾回收器回收，便會加入到一個注冊引用隊列中。

1. package com.qunar.base;
2. import java.lang.ref.Reference;
3. import java.lang.ref.ReferenceQueue;
4. import java.lang.ref.SoftReference;
5. import java.lang.ref.WeakReference;
6. /**
7. * Created by xiaosi on 16-3-24.
8. */
9. public class WeakReferenceDemo {
10. // 創建引用隊列
11. private ReferenceQueue referenceQueue = new ReferenceQueue<>();
12. public class MyObject {
13. @Override
14. protected void finalize() throws Throwable {
15. super.finalize();
16. // 被回收時輸出
17. System.out.println("MyObject is finalize called");
18. }
19. @Override
20. public String toString() {
21. return " I am MyObject";
22. }
23. }
24. public class CheckRefQueue implements Runnable {
25. Reference obj = null;
26. @Override
27. public void run() {
28. try {
29. // 如果對象被回收則進入引用隊列
30. obj = (Reference) referenceQueue.remove();
31. } catch (InterruptedException e) {
32. e.printStackTrace();
33. }
34. if (obj != null) {
35. System.out.println("Object for SoftReference is " + obj.get());
36. }
37. }
38. }
39. public void test() {
40. // 創建強引用
41. MyObject myObject = new MyObject();
42. // 構造myObject對象的弱引用 注冊到 引用隊列
43. WeakReference weakReference = new WeakReference<>(myObject, referenceQueue);
44. CheckRefQueue checkRefQueue = new CheckRefQueue();
45. Thread thread = new Thread(checkRefQueue);
46. thread.start();
47. // 刪除強引用 對myObject對象的引用只剩下弱引用
48. myObject = null;
49. System.out.println("Before GC: Weak Get = " + weakReference.get());
50. System.gc();
51. System.out.println("After GC: Weak Get = " + weakReference.get());
52. }
53. public static void main(String[] args) {
54. WeakReferenceDemo referenceDemo = new WeakReferenceDemo();
55. referenceDemo.test();
56. }
57. }

• 運行結果：

  Before GC: Weak Get = I am MyObject

  After GC: Weak Get = null

  MyObject is finalize called

  Object for SoftReference is null

   

  在GC之前，弱引用對象並未被垃圾回收器發現，因此通過weakRef.get()方法可以取得對應的強引用。但是只要進行垃圾回收，弱引用對象一旦被發現，便會立即被回收，並加入注冊引用隊列中。此時，再次通過weakRef.get()方法取得強引用就會失敗。

   

  備注：

  軟引用，弱引用都非常適合來保存那些可有可無的緩存數據。如果這樣做，當系統內存不足時，這些緩存數據會被回收，不會導致內存溢出。而當內存資源充足時，這些緩存數據又可以存在相當長的時間。

   

  4. 虛引用

  虛引用是所有引用類型中最弱的一個。一個持有虛引用的對象，和沒有引用幾乎是一樣的，隨時都可能被垃圾回收器回收。當試圖通過虛引用的get()方法取得強引用時，總是會失敗。並且，虛引用必須和引用隊列一起使用，它的作用在於跟蹤垃圾回收過程。

  當垃圾回收器准備回收一個對象時，如果發現它還有虛引用，就會在垃圾回收後，銷毀這個對象，獎這個虛引用加入引用隊列。

  1. package com.qunar.base;
  2.  
  3. import java.lang.ref.PhantomReference;
  4. import java.lang.ref.Reference;
  5. import java.lang.ref.ReferenceQueue;
  6. import java.lang.ref.WeakReference;
  7.  
  8. /**
  9. * Created by xiaosi on 16-3-24.
  10. */
  11. public class PhantomReferenceDemo {
  12. // 創建引用隊列
  13. private ReferenceQueue referenceQueue = new ReferenceQueue<>();
  14.  
  15. public class MyObject {
  16. @Override
  17. protected void finalize() throws Throwable {
  18. super.finalize();
  19. // 被回收時輸出
  20. System.out.println("MyObject is finalize called");
  21. }
  22.  
  23. @Override
  24. public String toString() {
  25. return " I am MyObject";
  26. }
  27. }
  28.  
  29. public class CheckRefQueue implements Runnable {
  30. Reference obj = null;
  31.  
  32. @Override
  33. public void run() {
  34. try {
  35. // 如果對象被回收則進入引用隊列
  36. obj = (Reference) referenceQueue.remove();
  37. // 等待 直到取得虛引用對象
  38. System.out.println("Object for PhantomReference is " + obj.get());
  39. System.exit(0);
  40. } catch (InterruptedException e) {
  41. e.printStackTrace();
  42. }
  43. if (obj != null) {
  44. System.out.println("Object for SoftReference is " + obj.get());
  45. }
  46. }
  47. }
  48.  
  49. public void test() throws InterruptedException {
  50. // 創建強引用
  51. MyObject myObject = new MyObject();
  52. // 構造myObject對象的虛引用 注冊到 引用隊列
  53. PhantomReference phantomReference = new PhantomReference<>(myObject, referenceQueue);
  54.  
  55. System.out.println("phantomReference Get : " + phantomReference.get());
  56.  
  57. CheckRefQueue checkRefQueue = new CheckRefQueue();
  58. Thread thread = new Thread(checkRefQueue);
  59. thread.start();
  60.  
  61. // 刪除強引用 對myObject對象的引用只剩下虛引用
  62. myObject = null;
  63. Thread.sleep(1000);
  64.  
  65. int i = 1;
  66.  
  67. while(true){
  68. System.out.println("第" + i + "次GC");
  69. System.gc();
  70. Thread.sleep(1000);
  71. i++;
  72. }//while
  73. }
  74.  
  75. public static void main(String[] args) throws InterruptedException {
  76. PhantomReferenceDemo referenceDemo = new PhantomReferenceDemo();
  77. referenceDemo.test();
  78. }
  79. }

  運行結果：

  phantomReference Get : null

  第1次GC

  MyObject is finalize called

  第2次GC

  Object for PhantomReference is null

   

  從這個輸出結果中可以看出，對虛引用的get()操作，總是返回null，即便強引用還存在時，也不例外。因為虛引用的get()實現：

  1. public T get() {
  2. return null;
  3. }

  在第一次GC時，系統找到了垃圾對象，並調用其finalize()方法回收內存，但沒有立即加入到回收隊列中。第二次GC時，該對象真正的被GC清除，此時，加入虛引用隊列。

   

  虛引用最大作用在於跟蹤對象回收，清理被銷毀對象的相關資源。通常，當對象不被使用時，重載該類的finalize()方法可以回收該對象的資源。但是，如果finalize()方法使用不慎，可能導致該對象復活。

  下面看一個錯誤的finalize()實現的例子，這個實現導致內存溢出，或者對象永遠無法被回收。

   

  1. package com.qunar.base;
  2.  
  3. /**
  4. * Created by xiaosi on 16-3-24.
  5. */
  6. public class PhantomObject {
  7. public static PhantomObject phantomObject;
  8. @Override
  9. protected void finalize() throws Throwable {
  10. super.finalize();
  11. // 被回收時輸出
  12. System.out.println("MyObject is finalize called");
  13. // 在finalize()中拯救了將要被回收的對象
  14. phantomObject = this;
  15. }
  16.  
  17. @Override
  18. public String toString() {
  19. return " I am MyObject";
  20. }
  21.  
  22. public static void main(String[] args) throws InterruptedException {
  23. phantomObject = new PhantomObject();
  24. // 刪除對象
  25. phantomObject = null;
  26. // 第一次GC
  27. System.gc();
  28.  
  29. Thread.sleep(1000);
  30. if(phantomObject == null){
  31. System.out.println("phantomObject is null");
  32. }//if
  33. else{
  34. System.out.println("phantomObject 可用");
  35. }
  36.  
  37. System.out.println("第二次GC");
  38. System.gc();
  39.  
  40. Thread.sleep(1000);
  41. if(phantomObject == null){
  42. System.out.println("phantomObject is null");
  43. }//if
  44. else{
  45. System.out.println("phantomObject 可用");
  46. }
  47.  
  48. System.out.println("第三次GC");
  49. System.gc();
  50.  
  51. Thread.sleep(1000);
  52. if(phantomObject == null){
  53. System.out.println("phantomObject is null");
  54. }//if
  55. else{
  56. System.out.println("phantomObject 可用");
  57. }
  58. }
  59. }
  
  

  在上面代碼中，先將對象phantomObject設置為null，告知GC這是一個需要清理的對象。然後，進行一次顯示的GC，GC過後發現，雖然該對象的finalize()方法被調用，但是對象依然存在。隨後，進行第二次GC，由於在GC之前沒有清除對象的強引用，所以phantomObject依然沒有被回收。

  運行結果：

   

  MyObject is finalize called

  phantomObject 可用

  第二次GC

  phantomObject 可用

  第三次GC

  phantomObject 可用

   

  可見，雖然finalize()被調用，但是phantomObject始終都沒有被回收。如果要強制回收phantomObject，需要在第二次G前，使用phantomObject=null，去除該對象的強引用。由於finalize()只會被調用一次，因此在第二次回收時，對象就沒有機會復活了。

  運行結果：

   

  MyObject is finalize called

  phantomObject 可用

  第二次GC

  phantomObject is null

  第三次GC

  phantomObject is null

  
  由於在finalize()中存在讓回收對象復活的可能性，因此，在一個復雜的應用系統中，一旦finalize()方法實現有問題，就很容易造成內存洩露。而使用虛引用來清理相關資源則不會有類似的問題，因為虛引用隊列中對象，事實上已經完成了對象的回收工作，是不可能再度復活該對象的。