JVM——从简单Demo分析Java 四种引用类型

以你之姓@ 2022-04-05 15:09 210阅读 0赞

有内存分配自然也就有内存回收，是否回收一个对象就需要判断它是否符合回收条件。

判断对象是否存活主要也就是引用计数法以及可达性分析算法。这两种算法可以参考：[JVM——引用计数算法与可达性分析算法][JVM]

但是无论是通过引用计数算法判断对象的引用数量，还是通过可达性分析算法判断对象的引用链是否可达，**判定对象是否存活都与“引用”有关。**

在JDK1.2以前，Java中的引用的定义很传统：如果reference类型的数据中存储的数值代表的是另一块内存的起始地址，就称这块内存代表着一个引用。

这种定义很纯粹，也很粗糙。作为一个新时代的有志青年，我们当然希望JDK可以能够分辨出更多种类的对象（就像女朋友希望我们能够多分辨一些口红的色号那样）。

JDK自然也知道我们的想法，因此在JDK1.2之后，Java就对引用的概念进行了扩充，将引用分为了**强引用（Strong Reference）、软引用（Soft Reference）、弱引用（Weak Reference）、虚引用（Phantom Reference）**四种。

而这四种引用类型，就是我们今天的主菜。我们今天就从JVM源码的角度，来分析分析Java的引用类型。

**1.强引用**

强引用就是指在程序代码中普遍存在的，类似于“**Object obj=new Object()**”这一类的引用。如果一个对象具有强引用，那垃圾回收器绝不会回收它。当内存空间不足，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足的问题。

强引用的特性如下：

*  强引用可以直接访问目标对象。
 *  强引用所指向的对象在任何时候都不会被系统回收。
 *  强引用可能导致内存泄漏。

强引用大家都熟悉，这里就不举例啦~

**2.软引用**

**软引用是用来描述一些还有用但并非必须的对象。**对于软引用关联着的对象，在系统将要发生内存溢出异常之前，将会把这些对象列进回收范围之中进行第二次回收。如果这次回收还没有足够的内存，才会抛出内存溢出异常。

对于软引用关联着的对象，如果内存充足，则垃圾回收器不会回收该对象，如果内存不够了，就会回收这些对象的内存。

在JDK 1.2 之后，提供了 **SoftReference 类**来实现软引用。**软引用可用来实现内存敏感的高速缓存。**

软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被垃圾回收器回收，Java虚拟机就会把这个软引用加入到与之关联的引用队列中。

**注意：Java 垃圾回收器准备对SoftReference所指向的对象进行回收时，调用对象的 finalize() 方法之前，SoftReference对象自身会被加入到这个 ReferenceQueue 对象中，此时可以通过 ReferenceQueue 的 poll() 方法取到它们。**

请看下面的代码Demo：

/**
     * 软引用：对于软引用关联着的对象，在系统将要发生内存溢出异常之前，将会把这些对象列进回收范围之中进行第二次回收( 因为是在第一次回收后才会发现内存依旧不充足，才有了这第二次回收 )。如果这次回收还没有足够的内存，才会抛出内存溢出异常。
     * 对于软引用关联着的对象，如果内存充足，则垃圾回收器不会回收该对象，如果内存不够了，就会回收这些对象的内存。
     * 通过debug发现，软引用在pending状态时，referent就已经是null了。
     *
     * 启动参数：-Xmx5m
     *
     */
    public class SoftReferenceDemo {
        private static ReferenceQueue<MyObject> queue = new ReferenceQueue<>();
        public static void main(String[] args) throws InterruptedException {
            Thread.sleep(3000);
            MyObject object = new MyObject();
            SoftReference<MyObject> softRef = new SoftReference(object, queue);
            new Thread(new CheckRefQueue()).start();
            object = null;
            System.gc();
            System.out.println("After GC : Soft Get = " + softRef.get());
            System.out.println("分配大块内存");
    
            /**
             * ====================== 控制台打印 ======================
             * After GC : Soft Get = I am MyObject.
             * 分配大块内存
             * MyObject's finalize called
             * Object for softReference is null
             * After new byte[] : Soft Get = null
             * ====================== 控制台打印 ======================
             *
             * 总共触发了 3 次 full gc。第一次有System.gc();触发；第二次在在分配new byte[5*1024*740]时触发，然后发现内存不够，于是将softRef列入回收返回，接着进行了第三次full gc。
             */
    //        byte[] b = new byte[5*1024*740];
    
            /**
             * ====================== 控制台打印 ======================
             * After GC : Soft Get = I am MyObject.
             * 分配大块内存
             * Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
             *      at com.bayern.multi_thread.part5.SoftReferenceDemo.main(SoftReferenceDemo.java:21)
             * MyObject's finalize called
             * Object for softReference is null
             * ====================== 控制台打印 ======================
             *
             * 也是触发了 3 次 full gc。第一次有System.gc();触发；第二次在在分配new byte[5*1024*740]时触发，然后发现内存不够，于是将softRef列入回收返回，接着进行了第三次full gc。当第三次 full gc 后发现内存依旧不够用于分配new byte[5*1024*740]，则就抛出了OutOfMemoryError异常。
             */
            byte[] b = new byte[5*1024*790];
    
            System.out.println("After new byte[] : Soft Get = " + softRef.get());
        }
    
        public static class CheckRefQueue implements Runnable {
            Reference<MyObject> obj = null;
            @Override
            public void run() {
                try {
                    obj = (Reference<MyObject>) queue.remove();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
    
                if (obj != null) {
                    System.out.println("Object for softReference is " + obj.get());
                }
            }
        }
    
        public static class MyObject {
            @Override
            protected void finalize() throws Throwable {
                System.out.println("MyObject's finalize called");
                super.finalize();
            }
            @Override
            public String toString() {
                return "I am MyObject.";
            }
        }
    }

** 3.弱引用**

弱引用也是用来描述非必须的对象，但是它的强度比软引用更弱一些，被弱引用关联的对象只能生存到下一次垃圾收集发生之前。当垃圾收集器工作时，无论当前内存是否足够，都会回收掉只被弱引用关联的对象。一旦一个弱引用对象被垃圾回收器回收，便会加入到一个注册引用队列中。在JDK1.2之后，提供了WeakReference类来实现弱引用。

**请看Demo：**

public class WeakReferenceDemo {
    
        private static ReferenceQueue<MyObject> queue = new ReferenceQueue<>();
    
        public static void main(String[] args) {
            MyObject object = new MyObject();
            Reference<MyObject> weakRef = new WeakReference<>(object, queue);
            System.out.println("创建的弱引用为 : " + weakRef);
            new Thread(new CheckRefQueue()).start();
            object = null;
            System.out.println("Before GC: Weak Get = " + weakRef.get());
            System.gc();
            System.out.println("After GC: Weak Get = " + weakRef.get());
        }
    
        public static class CheckRefQueue implements Runnable {
            Reference<MyObject> obj = null;
            @Override
            public void run() {
                try {
                    obj = (Reference<MyObject>)queue.remove();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if(obj != null) {
                    System.out.println("删除的弱引用为 : " + obj + " , 获取到的弱引用的对象为 : " + obj.get());
                }
            }
        }
    
        public static class MyObject {
            @Override
            protected void finalize() throws Throwable {
                System.out.println("MyObject's finalize called");
                super.finalize();
            }
            @Override
            public String toString() {
                return "I am MyObject";
            }
        }
    }

运行结果如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1NlYXJjaGluX1I_size_16_color_FFFFFF_t_70][]

**注意：Java 垃圾回收器准备对WeakReference所指向的对象进行回收时，调用对象的 finalize() 方法之前，WeakReference对象自身会被加入到这个 ReferenceQueue 对象中，此时可以通过 ReferenceQueue 的 poll() 方法取到它们。**  
  
**4.虚引用**

虚引用也称作幽灵引用或者幻影引用，至于为什么取这样的名字，那自然是因为它太弱啦。在这四种引用关系中，虚引用是最弱的一种引用关系。它弱到**一个对象是否有虚引用的存在，完全不会对其生存时间构成影响**。且不同于软引用和弱引用，**虚引用无法通过 get() 方法来取得目标对象的强引用从而使用目标对象，观察源码可以发现 get() 被重写为永远返回 null**。

既然虚引用这么弱，那还要虚引用做什么呢？

**为一个对象设置虚引用关联的唯一目的就是能够在这个对象被收集器回收的时候收到一个系统通知（即跟踪对象的垃圾回收）。**

换句话说，其实**虚引用主要被用来跟踪对象被垃圾回收的状态，通过查看引用队列中是否包含对象所对应的虚引用来判断它是否 即将被垃圾回收，从而采取行动。**它并不被期待用来取得目标对象的引用，而目标对象被回收前，它的引用会被放入一个 ReferenceQueue 对象中，从而达到跟踪对象垃圾回收的作用。当phantomReference被放入队列时，说明referent的finalize()方法已经调用，并且垃圾收集器准备回收它的内存了。

**注意：对于Phantom Reference 来说，只有在当 Java 垃圾回收器对其所指向的对象真正进行回收时，才会将其加入到这个 ReferenceQueue 对象中，这样就可以追综对象的销毁情况。由于这个时候referent对象的finalize()方法已经调用过了。**所以具体用法和之前两个有所不同，它必须传入一个 ReferenceQueue 对象。当虚引用所引用对象准备被垃圾回收时，虚引用会被添加到这个队列中。

**请看Demo1：**

public class PhantomReferenceDemo {
        private static ReferenceQueue<MyObject> queue = new ReferenceQueue<>();
        public static void main(String[] args) throws InterruptedException {
            MyObject object = new MyObject();
            Reference<MyObject> phanRef = new PhantomReference<>(object, queue);
            System.out.println("创建的虚拟引用为 : " + phanRef);
            new Thread(new CheckRefQueue()).start();
            object = null;
            int i = 1;
            while (true) {
                System.out.println("第" + i++ + "次GC");
                System.gc();
                TimeUnit.SECONDS.sleep(1);
            }
        }
        public static class MyObject {
            @Override
            protected void finalize() throws Throwable {
                System.out.println("MyObject's finalize called");
                super.finalize();
            }
            @Override
            public String toString() {
                return "I am MyObject";
            }
        }
    
        public static  class CheckRefQueue implements Runnable {
            Reference<MyObject> obj = null;
            @Override
            public void run() {
                try {
                    obj = (Reference<MyObject>)queue.remove();
                    System.out.println("删除的虚引用为: " + obj + " , 获取虚引用的对象 : " + obj.get());
                    System.exit(0);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

在这个程序中，在经过一次GC之后，系统找到了垃圾对象，并调用finalize()方法回收内存，但没有立即加入PhantomReference Queue中。  
因为MyObject对象重写了finalize()方法，并且该方法是一个非空实现，所以这里MyObject也是一个Final Reference。所以第一次GC完成的是Final Reference的事情。  
而第二次GC时，该对象(即MyObject)对象会真正被垃圾回收器进行回收，此时，将PhantomReference加入虚引用队列( PhantomReference Queue )。  
而且每次gc之间需要停顿一些时间，已给JVM足够的处理时间；如果这里没有TimeUnit.SECONDS.sleep(1); 可能需要gc到第5、6次才会成功。

运行结果如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1NlYXJjaGluX1I_size_16_color_FFFFFF_t_70 1][]

**Demo2：**

public class PhantomReferenceDemo2 {
    
        public static void main(String[] args) {
            ReferenceQueue<MyObject> queue = new ReferenceQueue<>();
            MyObject object = new MyObject();
            Reference<MyObject> phanRef = new PhantomReference<>(object, queue);
            System.out.println("创建的虚拟引用为 : " + phanRef);
            object = null;
            System.out.println(phanRef.get());
            System.gc();
            System.out.println("referent : " + phanRef);
            System.out.println(queue.poll() == phanRef); //true
        }
    
        public static class MyObject {
            @Override
            public String toString() {
                return "I am MyObject";
            }
        }
    }

这个程序与上面这个demo1不同，这里因为MyObject没有重写finalize()方法，所以这里的在System.gc()后就会处理PhantomReference加入到PhantomReference Queue中。

程序运行结果为：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1NlYXJjaGluX1I_size_16_color_FFFFFF_t_70 2][]

好啦，以上就是关于Java四种引用类型的相关知识总结啦，如果大家有什么不明白的地方或者发现文中有描述不好的地方，欢迎大家留言评论，我们一起学习呀。

***Biu~~~~~~~~~~~~~~~~~~~~![å®«å´éªé¾ç«è¡¨æå|é¾ç«gifå¾è¡¨æåä¸è½½å¾ç][gif]~~~~~~~~~~~~~~~~~~~~~~pia！***

参考文章：[https://www.jianshu.com/p/9a089a37f78d][https_www.jianshu.com_p_9a089a37f78d]

[JVM]: https://blog.csdn.net/Searchin_R/article/details/84980843
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1NlYXJjaGluX1I_size_16_color_FFFFFF_t_70]: /images/20220405/2b9e70f877eb432ba305994e4fc22d20.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1NlYXJjaGluX1I_size_16_color_FFFFFF_t_70 1]: /images/20220405/9056b26edec74431b4ffeefc3fc03565.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1NlYXJjaGluX1I_size_16_color_FFFFFF_t_70 2]: /images/20220405/a4f6141441fa4af396885e39af68cdd1.png
[gif]: http://pic.qqtn.com/up/2016-8/20168111740476121.gif
[https_www.jianshu.com_p_9a089a37f78d]: https://www.jianshu.com/p/9a089a37f78d