[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<MyObject> 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<MyObject> obj = null;
  25.        @Override
  26.        public void run() {
  27.            try {
  28.                // 如果對象被回收則進入引用隊列
  29.                obj = (Reference<MyObject>) 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<MyObject> 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<MyObject> 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<MyObject> obj = null;
  26.        @Override
  27.        public void run() {
  28.            try {
  29.                // 如果對象被回收則進入引用隊列
  30.                obj = (Reference<MyObject>) 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<MyObject> 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. import java.lang.ref.PhantomReference;
  3. import java.lang.ref.Reference;
  4. import java.lang.ref.ReferenceQueue;
  5. import java.lang.ref.WeakReference;
  6. /**
  7. * Created by xiaosi on 16-3-24.
  8. */
  9. public class PhantomReferenceDemo {
  10.    // 創建引用隊列
  11.    private ReferenceQueue<MyObject> 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<MyObject> obj = null;
  26.        @Override
  27.        public void run() {
  28.            try {
  29.                // 如果對象被回收則進入引用隊列
  30.                obj = (Reference<MyObject>) referenceQueue.remove();
  31.                // 等待 直到取得虛引用對象
  32.                System.out.println("Object for PhantomReference is " + obj.get());
  33.                System.exit(0);
  34.            } catch (InterruptedException e) {
  35.                e.printStackTrace();
  36.            }
  37.            if (obj != null) {
  38.                System.out.println("Object for SoftReference is " + obj.get());
  39.            }
  40.        }
  41.    }
  42.    public void test() throws InterruptedException {
  43.        // 創建強引用
  44.        MyObject myObject = new MyObject();
  45.        // 構造myObject對象的虛引用 注冊到 引用隊列
  46.        PhantomReference<MyObject> phantomReference = new PhantomReference<>(myObject, referenceQueue);
  47.        System.out.println("phantomReference Get : " + phantomReference.get());
  48.        CheckRefQueue checkRefQueue = new CheckRefQueue();
  49.        Thread thread = new Thread(checkRefQueue);
  50.        thread.start();
  51.        // 刪除強引用 對myObject對象的引用只剩下虛引用
  52.        myObject = null;
  53.        Thread.sleep(1000);
  54.        int i = 1;
  55.        while(true){
  56.            System.out.println("第" + i + "次GC");
  57.            System.gc();
  58.            Thread.sleep(1000);
  59.            i++;
  60.        }//while
  61.    }
  62.    public static void main(String[] args) throws InterruptedException {
  63.        PhantomReferenceDemo referenceDemo = new PhantomReferenceDemo();
  64.        referenceDemo.test();
  65.    }
  66. }

運行結果:

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

在上面代碼中,先將對象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()方法實現有問題,就很容易造成內存泄露。而使用虛引用來清理相關資源則不會有類似的問題,因為虛引用隊列中對象,事實上已經完成了對象的回收工作,是不可能再度復活該對象的。












注意!

本站转载的文章为个人学习借鉴使用,本站对版权不负任何法律责任。如果侵犯了您的隐私权益,请联系我们删除。



 
粤ICP备14056181号  © 2014-2020 ITdaan.com