?

?

一、前言 二、四种引用

Java两种数据类型：8种值类型和3种引用类型（类、接口、数组），不管哪种引用类型，都要有相应的引用。

在Java中提供了四个级别的引用：强引用，软引用，弱引用和虚引用。在这四个引用类型中，只有强引用FinalReference类是包内可见，其他三种引用类型均为public，可以在应用程序中直接使用。引用类型的类结构如图所示。

金手指1：四种引用类型都是继承Reference抽象类，其中，只有强引用FinalReference类是包内可见，其他三种引用类型均为public。

2.1 强引用 FinalReference

Java中默认声明的就是强引用，例如以下代码，如果M对象被回收了，会打印finalize()方法中的内容：

public class FinalReferenceDemo {
    public static void main(String[] args) throws Exception {
        M m = new M();  //只要m还指向M对象，M对象就不会被回收
        // m = null;   //手动置null
        System.gc();  // 进行垃圾回收,这个只能进行通知作用,所以最好等1秒钟,让main函数走慢一点

        Thread.sleep(1000);
    }
}

class M {
    @Override
    protected void finalize() {
        System.out.println("对象被回收了...");
    }
}

运行结果：

只要强引用存在，垃圾收集器将永远不会回收被引用的对象，哪怕内存不足时，JVM也会直接抛出OutOfMemoryError，不会去回收。如果想中断强引用与对象之间的联系，可以显示的将强引用赋值为null，这样一来，JVM就可以适时的回收对象了。例如上面的代码，将 m = null; 注释放开时，运行结果如下：

2.2 软引用 SoftReference

软引用是用来描述一些非必需但仍有用的对象。在内存足够的时候，软引用对象不会被回收，只有在内存不足时，系统则会回收软引用对象，如果回收了软引用对象之后仍然没有足够的内存，才会抛出OutOfMemoryError。这种特性常常被用来实现缓存技术，比如网页缓存，图片缓存等。

在 JDK1.2 之后，用 SoftReference 类来表示软引用。下面以一个例子来进一步说明强引用和软引用的区别。

在运行下面的Java代码之前，需要先配置参数 -Xms2M -Xmx2M，将 JVM 的初始内存设为2M，最大可用内存为 2M。

首先先来测试一下强引用，在限制了 JVM 内存的前提下，下面的代码运行正常。

public class Demo {
    public static void main(String[] args) {
        // 当 new byte为 1M 时，程序运行正常
        byte[] buff1 = new byte[1024 * 1024 * 1];
        
        // byte[] buff2 = new byte[1024 * 1024 * 1];
    }
}

但是如果我们再创建一个1M大小的 byte数组时，则内存不够使用，程序直接报错。因为强引用不会被回收。

2.2.1 对象仅被软引用指向

接着来看一下软引用会有什么不一样，在下面的示例中先创建一个大小为 1M 的软引用对象，打印m的地址，然后进行垃圾回收，休眠500ms后打印m的地址。最后又创建了一个1M的字节数组，打印m的地址。

public class Demo {
    public static void main(String[] args) {
        SoftReference<byte[]> m = new SoftReference<>(new byte[1024 * 1024]);

        System.out.println(m.get());
        System.gc();
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(m.get());
        // 再分配一个数组，heap将装不下，
        // 这时系统会进行垃圾回收，如果内存不够，会把软引用干掉
        byte[] b = new byte[1024*1024*1];
        System.out.println(m.get());
    }
}

运行结果：

根据运行结果，我们可以看到，在内存不足的情况下，软引用才会被回收。

2.2.2 对象同时被强引用和软引用指向

让我们来看看软引用是怎样做缓存的，如下;

import java.lang.ref.SoftReference;

class Worker{

}
public class SoftReferenceDemo {
    public static void main(String[] args) {
        // new；分配内存、内存中分配对象、对象地址赋值给引用
        Worker worker=new Worker();
        // 使用软引用softReference指向
        SoftReference softReference=new SoftReference(worker);
        // 去掉强引用worker
        worker=null; 
        
        // 大量业务操作....  
        
        if (softReference!=null){
            // 将对象从软引用中拿出来，又变成了强引用指向，意义在于这样从软引用中get出来，要比new出来高效很多。
            // new出来要分配内存、内存中分配对象、对象地址赋值给引用
          worker=(Worker)softReference.get();
        }else{
            // 这个软引用已经被回收，只能new出来
          worker=new Worker();
          // 再让软引用指向
          softReference=new SoftReference(worker);
        }
    }
}

第二次拿出来 worker=(Worker)softReference.get(); 又是强引用指向，软引用存在的意义在于，从第一次new创建出来、软引用指向、强引用去掉，到第二次 worker=(Worker)softReference.get(); 这个过程中，是软引用指向，而不是强引用指向，这样如果中间大量业务操作，内存不够会回收 这个 new Worker() 对象，因为它被软引用指向，而不会 OOM 内存溢出。

2.3 弱引用 WeakReference

弱引用的引用强度比软引用要更弱一些，无论内存是否足够，只要 JVM 开始进行垃圾回收，那些被弱引用关联的对象都会被回收。在 JDK1.2 之后，用 WeakReference 来表示弱引用。

2.3.1 对象仅被弱引用指向

我们以与软引用同样的方式来测试一下弱引用：

public class Demo {
    public static void main(String[] args) {
        WeakReference<byte[]> m = new WeakReference<>(new byte[1024 * 1024]);

        System.out.println(m.get());
        System.gc(); 
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 这个对象仅仅被弱引用指向，没有被强引用指向，所以System.gc就可以为null了
        System.out.println(m.get());
    }
}

运行结果：

根据运行结果，可以发现垃圾回收后被弱引用关联的对象被回收了。

在 Java 集合中有一种特殊的 Map 类型：WeakHashMap， 在这种 Map 中存放了键对象的弱引用，当一个键对象被垃圾回收，那么相应的值对象的引用会从 Map 中删除。WeakHashMap 能够节约存储空间，可用来缓存那些非必须存在的数据。

2.3.2 对象同时被强引用和弱引用指向

import java.lang.ref.WeakReference;

class WeakReferenceDemo {
    public static void main(String[] args) throws Exception {
        // 100M 大小的缓存数据
        byte[] cacheData = new byte[100 * 1024 * 1024];
        // 将缓存对象弱引用持有,直接传递参数给构造函数
        WeakReference<byte[]> weakReference = new WeakReference<>(cacheData);
        System.out.println("第一次GC前：" + cacheData);     // 此时打印强引用，一定有，因为强引用未设置为null
        System.out.println("第一次GC前：" + weakReference.get());  // 此时打印弱引用，一定有，因为强引用未设置为null,且尚未指向一次gc操作
        // 第一次gc并查看对象的情况
        System.gc();
        Thread.sleep(1000);
        System.out.println("第一次GC后：" + cacheData);  // 此时打印强引用，一定有，因为强引用未设置为null
        System.out.println("第一次GC后：" + weakReference.get());   // 此时打印弱引用，一定有，未被回收，因为强引用未设置为null，即使执行了gc操作，弱引用也还在

        // 将缓存数据的强引用去掉,再次执行gc操作
        cacheData = null;
        System.gc();
        Thread.sleep(1000);
        System.out.println("第二次GC后：" + cacheData);  // 此时打印强引用，一定为null，因为强引用设置为null
        System.out.println("第二次GC后：" + weakReference.get());   // 此时打印弱引用，一定没有，已被回收，因为强引用设置为null，且执行了gc操作，同时满足两个条件，所以弱引用被回收了

    }
}

第一次GC前：[B@c4437c4
第一次GC前：[B@c4437c4
第一次GC后：[B@c4437c4
第一次GC后：[B@c4437c4
第二次GC后：null
第二次GC后：null

对比四个引用：

强引用：
不回收：没有设置为null，指向实例对象；
回收：设置为null，指向gc操作（ System.gc(); Thread.sleep(1000);）；
作用：写代码，就算oom，也不会回收。

软引用：
不回收：不同时满足三个条件；
回收：强引用设置为null，且内存不够不回收就会造成OOM，且执行gc操作，同时满足三个条件，弱引用被回收；
作用：缓存。

弱引用：
不回收：不同时满足两个条件；
回收：强引用设置为null，且执行了gc操作，同时满足两个条件，弱引用被回收；
作用：略。

弱引用：
不回收：
回收：
作用：通知。

2.3.3 引用队列

import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;

public class Demo {
    public static void main(String[] args) throws Exception{
        Object obj = new Object();
        ReferenceQueue<Object> queue = new ReferenceQueue<Object>();
        WeakReference<Object> weakRef = new WeakReference<Object>(obj, queue);
        System.out.println(obj);         // 强引用  有
        System.out.println(weakRef.get());  // 弱引用  有
        System.out.println(queue.poll());    // 引用队列  null

        System.out.println("=====================");
        obj = null;
        System.gc();
        Thread.sleep(1000);
        System.out.println(obj);             //  强引用 null 
        System.out.println(weakRef.get());  //弱引用  null
        System.out.println(queue.poll());     // 引用队列 有
    }
}

输出结果：

java.lang.Object@c4437c4
java.lang.Object@c4437c4
null
=====================
null
null
java.lang.ref.WeakReference@433c675d

引用队列的作用：打印已经被回收的对象的引用，上面是弱引用。引用队列的作用就是监控引用，将需要监控的引用放到引用队列中，打印这些信息，即这些引用已经被回收了可以打印它们的信息。

2.4 虚引用 PhantomReference

虚引用是最弱的一种引用关系，如果一个对象仅持有虚引用，那么它就和没有任何引用一样，它随时可能会被回收。PhantomReference 只有一个构造函数和一个 get() 方法，而且它的 get() 方法仅仅是返回一个null，也就是说将永远无法通过虚引用来获取对象，唯一的作用就是通知。

虚引用必须要和 ReferenceQueue 引用队列一起使用，因为不能直接get出来，只能通过引用队列拿出来。

API:

public class PhantomReference<T> extends Reference<T> {
    public T get() {
        return null;
    }

    public PhantomReference(T referent, ReferenceQueue<? super T> q) {
        super(referent, q);
    }
}

当垃圾回收器准备回收一个对象时，如果发现它还有引用，那么就会在回收对象之前，把这个引用加入到与之关联的引用队列中去。主要用于清理堆外内存。

特点：如同虚设，和没有引用没什么区别

虚引用和前面的软引用、弱引用不同，它并不影响对象的生命周期。在java中用java.lang.ref.PhantomReference类表示。如果一个对象与虚引用关联，则跟没有引用与之关联一样，在任何时候都可能被垃圾回收器回收。

要注意的是，虚引用必须和引用队列关联使用，当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会把这个虚引用加入到与之关联的引用队列中。程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。如果程序发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。

示例：

import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;

class Demo{
    public static void main(String[] args) throws Exception{
        Object obj = new Object();
        ReferenceQueue<Object> queue = new ReferenceQueue<Object>();
        PhantomReference<Object> pr = new PhantomReference<Object>(obj, queue);
        System.out.println(obj);   // 强引用 有  java.lang.Object@c4437c4
        System.out.println(pr.get());  // 虚引用 有 但是取出来为null  虚引用get永远为null
        System.out.println(queue.poll()); // 引用队列， null

        System.out.println("=====================");
        obj = null;
        System.gc();
        Thread.sleep(1000);

        System.out.println(obj);             //  强引用 没有,null
        System.out.println(pr.get());  //  虚引用  没有，null  虚引用get永远为null
        System.out.println(queue.poll());     // 引用队列 虚引用已经为null,所以可以取出来  java.lang.ref.PhantomReference@433c675d

    }
}

java.lang.Object@c4437c4
null
null
=====================
null
null
java.lang.ref.PhantomReference@433c675d

虚引用的主要作用是跟踪对象被垃圾回收的状态。仅仅是提供了一种确保对象被finalize以后，做某些事情的机制。PhantomRefrence的get方法总是返回null，因此无法访问对应的引用对象。其意义在于说明一个对象已经进入finalization阶段，可以被GC回收，用来实现比finalization机制更灵活的回收操作。

换句话说，设置虚引用关联的唯一目的，就是在这个对象被收集器回收的时候收到一个系统通知或者后续添加进一步的处理。Java技术允许使用finalize()方法在垃圾收集器将对象从内存中清除之前做必要的清理工作。

2.5 小结

类结构关系图：四种引用类型都是继承Reference抽象类；

访问权限：只有强引用FinalReference类是包内可见，其他三种引用类型均为public。

四种引用的使用对比，如下：

?	强引用FinalReference	软引用SoftReference	弱引用WeakReferece	虚引用PhantomReference
什么时候释放	两个条件（System.gc()/自动内存回收+内存不够）同时满足也不释放，永远都不会释放，内存不够就OOM，不释放，除非将引用设置为null，System.gc()才释放	两个条件：System.gc()/自动内存回收+内存不够，同时满足，回收	一个条件： System.gc()/自动内存回收，回收	无条件：任意时候都可以回收
作用	程序员写代码都是使用强引用，引用只要不设置为null，System.gc()和自动垃圾都无法回收，保证程序绝对可靠运行，内存不够就OOM异常	作用：缓存技术，比如网页缓存，图片缓存，如果内存不够，就清空缓存保护内存（总不能因为缓存把程序OOM吧，程序OOM只有一个原因，那就是强引用，而强引用是程序员可以把握的，所有OOM是程序员可以处理的）	WeakHashMap 节约存储空间，作为缓存一些不重要的数据	一般无作用（记住一点，PhantomReference 源码，发现它只有一个构造函数和一个 get() 方法，而且它的 get() 方法仅仅是返回一个null，也就是说将永远无法通过虚引用来获取对象，即虚引用必须要和 ReferenceQueue 引用队列一起使用）

优先级：强引用 > 内存不够OOM > 软引用 > 弱引用 >虚引用。

金手指1：强引用的优先级比OOM高

强引用作用：程序员写代码都是使用强引用，引用只要不设置为null，System.gc()和自动垃圾都无法回收，保证程序绝对可靠运行，内存不够就OOM异常。

金手指2：软引用的优先级比OOM低

软引用作用：缓存技术，比如网页缓存，图片缓存，如果内存不够，就清空缓存保护内存（总不能因为缓存把程序OOM吧，程序OOM只有一个原因，那就是强引用，而强引用是程序员可以把握的，所有OOM是程序员可以处理的）。

联系：强引用是造成OOM的元凶，软引用的软引用的出现是虚拟机更好的管理内存的表现，几乎所有的图片框架和阿里云的鹰眼检查都使用大量的软引用。

软引用的适用场景：内存占用大的对象、生命周期长的对象、使用不频繁的对象。对于内存占用大的对象 或 生命周期长的对象，用软引用放到缓存里面，下一次get出来，比强引用指向，下一次new出来，要高效很多。对于使用不频繁的对象，用软引用放到缓存里面，下一次get出来，如果是频繁使用的对象，永远用强引用就好。

软引用劣势：不销毁对象放在内存中，让内存占用率高，再垃圾收集之前，造成内存占用率高，如60%~90%。

三、对象生命周期

3.1 对象生命周期

虚拟中对引用的定义，即必须满足两个条件：
第一，引用的类型为Reference及其子类；
第二，引用存储的数据是另一块内存地址。

所以，对于一个对象，经过 gc root + 可达性分析，只有两种情况，要么此对象被引用，要么此对象没有被引用，前者不可回收，后者需要被gc回收。

但是，并不是 被可达性分析 判定为 不可达 之后，就立马回收，这里涉及到 对象的生命周期。

3.2 各个阶段

创建阶段：

instance = new Singleton();

第一步，分配一块内存M；
第二步，在内存M上初始化Singleton对象，得到M的地址；
第三步，然后M的地址返回给instance变量。 // 最后赋值给instance变量

应用阶段：当一个对象至少被一个强应用所指向，这个对象进入应用阶段。

不可见阶段：超出对象所有引用的作用域，如：

public class Person {
    public static int calc(int op1,int op2){
        int result =  op1 + op2;
        Object object=new Object();   // 这个object仅仅在 7 8 行可见，其他地方就是不可见的，就是超过对象的所有引用的作用域
        return result;
    }
    public static void main(String[] args) {
     System.out.println(calc(1,2));
    }
}

不可达阶段：判断为不可见之后(前置条件)，又被 gc root + 可达性分析，判断为是否 不可达。

收集阶段：满足三个条件，该不可达对象可以复活一次，达到应用阶段，三个条件分别是：
已重写finalize方法 + 尚未调用finalize方法一次 + finalize方法中为该对象设置强引用

收集阶段的 finalize() 方法只能复活一次，代码如下：

public class Finalize {
    private static Finalize save_hook =null;
    public void isLive(){
        System.out.println("我还活着");
    }

    @Override
    protected void finalize() throws Throwable {
        System.out.println("finalize方法被执行");
        Finalize.save_hook=this;
    }

    public static void main(String[] args) throws Exception{
    // 第一次，新建对象，去掉强引用指向gc操作，但是gc操作之前的finalize方法，
    // 让这个类变量save_hook重新指向当前对象，所以save_hook!=null走if,打印 我还活着
        save_hook = new Finalize();
        save_hook=null;
        System.gc();
        Thread.sleep(1000);
        if (save_hook!=null){
            save_hook.isLive();
        }else{
            System.out.println("好了，我现在已经死了");
        }

        // 第二次，去掉强引用指向gc操作，所以走 save_hook==null走else,打印 我终于死亡了
        save_hook=null;
        System.gc();
        Thread.sleep(1000);
        if (save_hook!=null){
            save_hook.isLive();
        }else{
            System.out.println("我终于死亡了");
        }
    }
}

执行结果：

finalize方法被执行
我还活着
我终于死亡了

终结阶段：对象被销毁。

空间重分配阶段：内存空间重新为下一个对象分配内存。

四、尾声

虚拟机四种引用类型和对象的生命周期，完成了。

天天打码，天天进步！！！