Java中的四种引用类型

Java中的四种引用类型：强引用、软引用、弱引用和虚引用

有四种引用类型的原因

在Java中是由JVM负责内存的分配和回收，这是它的优点（简化编程者的工作，不需要像C语言那样去手动操作内存），但同时也是它的缺点（不够灵活，垃圾回收对于编程者来说是不可控的）。
在JDK1.2以前，如果一个对象不被任何变量引用，则程序无法再次使用这个对象，这个对象最终会被GC（GabageCollection：垃圾回收）。但是如果之后可能还会用到这个对象，就只能去新建一个了，这其实就降低了JVM性能，没有达到最大的优化策略。
因此，从JDK1.2开始，提供了四种类型的引用：强引用（StrongReference）、软引用（SoftReference）、弱引用（WeakReference）和虚引用（PhantomReference）。主要有两个目的：

• 可以在代码中决定某些对象的生命周期；
• 优化JVM的垃圾回收机制。

四种引用类型

1.强引用

强引用是最普遍的引用，如果一个对象具有强引用，垃圾回收器不会回收该对象，当内存空间不足时，JVM 宁愿抛出 OutOfMemoryError异常；只有当这个对象没有被引用时，才有可能会被回收。

package com.lzumetal.jvmtest;

import java.util.ArrayList;
import java.util.List;

public class StrongReferenceTest {

    static class BigObject {
        private Byte[] bytes = new Byte[1024 * 1024];
    }


    public static void main(String[] args) {
        List<BigObject> list = new ArrayList<>();
        while (true) {
            BigObject obj = new BigObject();
            list.add(obj);
        }
    }
}

BigObject obj = new BigObject()创建的这个对象时就是强引用，上面的main方法最终将抛出OOM异常：

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
    at com.lzumetal.jvm.StrongReferenceTest$BigObject.<init>(StrongReferenceTest.java:9)
    at com.lzumetal.jvm.StrongReferenceTest.main(StrongReferenceTest.java:16)

2.软引用

软引用是除了强引用外，最强的引用类型。可以通过java.lang.ref.SoftReference使用软引用。

• 当内存空间足够，垃圾回收器就不会回收它。
• 当内存空间不足了，就会回收该对象。
• JVM会优先回收长时间闲置不用的软引用的对象，对那些刚刚构建的或刚刚使用过的“新”软引用对象会尽可能保留。
• 如果回收完还没有足够的内存，才会抛出内存溢出异常。只要垃圾回收器没有回收它，该对象就可以被程序使用。

SoftReference的特点是它的一个实例保存对一个Java对象的软引用， 该软引用的存在不妨碍垃圾收集线程对该Java对象的回收。也就是说，一旦SoftReference保存了对一个Java对象的软引用后，在垃圾线程对 这个Java对象回收前，SoftReference类所提供的get()方法返回Java对象的强引用。一旦垃圾线程回收该Java对象之后，get()方法将返回null。

下面举一个例子说明软引用的使用方法。
参考:https://www.cnblogs.com/doyi111/p/11719105.html
在你的IDE设置参数 -Xmx2m -Xms2m规定堆内存大小为2m。

    @Test
    public void test3(){
        MyObject obj = new myObject();
        SoftReference sf = new SoftReference<>(obj);
        obj = null;
        System.gc();
//        byte[] bytes = new byte[1024*100];
//        System.gc();
        System.out.println("是否被回收"+sf.get());
    }

运行结果：

是否被回收cn.zyzpp.MyObject@42110406

打开被注释掉的new byte[1024*100]语句，这条语句请求一块大的堆空间，使堆内存使用紧张。并显式的再调用一次GC，结果如下：

是否被回收null

说明在系统内存紧张的情况下，软引用被回收。

三，弱引用

弱引用的引用强度比软引用要更弱一些，无论内存是否足够，只要 JVM 开始进行垃圾回收，那些被弱引用关联的对象都会被回收。
在 JDK1.2 之后，用 java.lang.ref.WeakReference 来表示弱引用。
我们以与软引用同样的方式来测试一下弱引用：

private static void testWeakReference() {
	for (int i = 0; i < 10; i++) {
		byte[] buff = new byte[1024 * 1024];
		WeakReference<byte[]> sr = new WeakReference<>(buff);
		list.add(sr);
	}
	
	System.gc(); //主动通知垃圾回收
	
	for(int i=0; i < list.size(); i++){
		Object obj = ((WeakReference) list.get(i)).get();
		System.out.println(obj);
	}
}

打印结果：

null
null
null
null
null
......

可以发现所有被弱引用关联的对象都被垃圾回收了。

4.虚引用

与其他三种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收。

虚引用主要用来跟踪对象被垃圾回收的活动。虚引用与软引用和弱引用的一个区别在于：虚引用必须和引用队列（ReferenceQueue）联合使用。当垃 圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。

Object object = new Object();
ReferenceQueue queue = new ReferenceQueue ();
PhantomReference pr = new PhantomReference (object, queue); 

程序可以通过判断引用队列中是 否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。程序如果发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。

在实际程序设计中一般很少使用弱引用与虚引用，使用软引用的情况较多，这是因为软引用可以加速JVM对垃圾内存的回收速度，可以维护系统的运行安全，防止内存溢出（OutOfMemory）等问题的产生。

补充: ReferenceQueue和Reference

1.ReferenceQueue(引用队列)

参考:https://segmentfault.com/a/1190000015282652
SoftReference对象是用来保存软引用，但它同时也是一个Java对象。所以，当软可及对象被回收之后，虽然这个SoftReference对象的get()方法返回null，但SoftReference对象本身并不是null，而此时这个SoftReference对象已经不再具有存在的价值，需要一个适当的清除机制，避免大量SoftReference对象带来的内存泄漏。

在java.lang.ref包里还提供了ReferenceQueue。如果在创建SoftReference对象的时候，使用了一个ReferenceQueue对象作为参数提供给SoftReference的构造方法，如:

Person person = new Person("张三");
ReferenceQueue<Person> queue = new ReferenceQueue<>();
SoftReference<Person> softReference = new SoftReference<Person>(person, queue);

在SoftReference所软引用的Person对象被垃圾回收时，JVM会先将softReference对象添加到ReferenceQueue这个队列中。当我们调用ReferenceQueue的poll()方法，如果这个队列中不是空队列，那么将返回并移除前面添加的那个Reference对象。
还是上面的那个例子，测试代码：

public static void main(String[] args) throws InterruptedException {
    Person person = new Person("张三");
    ReferenceQueue<Person> queue = new ReferenceQueue<>();
    SoftReference<Person> softReference = new SoftReference<Person>(person, queue);

    person = null;//去掉强引用，new Person("张三")的这个对象就只有软引用了

    Person anotherPerson = new Person("李四");
    Thread.sleep(1000);

    System.err.println("软引用的对象 ------->" + softReference.get());

    Reference softPollRef = queue.poll();
    if (softPollRef != null) {
        System.err.println("SoftReference对象中保存的软引用对象已经被GC，准备清理SoftReference对象");
        //清理softReference
    }
}

控制台输出：

[GC (Allocation Failure) [PSYoungGen: 1536K->504K(2048K)] 1536K->728K(7680K), 0.0022378 secs] [Times: user=0.03 sys=0.05, real=0.00 secs] 
[GC (Allocation Failure) [PSYoungGen: 1036K->504K(2048K)] 5356K->4840K(7680K), 0.0027540 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [PSYoungGen: 504K->504K(2048K)] 4840K->4840K(7680K), 0.0048557 secs] [Times: user=0.00 sys=0.00, real=0.01 secs] 
[Full GC (Allocation Failure) [PSYoungGen: 504K->0K(2048K)] [ParOldGen: 4336K->4774K(5632K)] 4840K->4774K(7680K), [Metaspace: 3468K->3468K(1056768K)], 0.0087802 secs] [Times: user=0.11 sys=0.00, real=0.01 secs] 
[GC (Allocation Failure) [PSYoungGen: 0K->0K(2048K)] 4774K->4774K(7680K), 0.0005462 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[Full GC (Allocation Failure) [PSYoungGen: 0K->0K(2048K)] [ParOldGen: 4774K->659K(5632K)] 4774K->659K(7680K), [Metaspace: 3468K->3468K(1056768K)], 0.0104794 secs] [Times: user=0.05 sys=0.02, real=0.01 secs] 
软引用的对象 ------->null
SoftReference对象中保存的软引用对象已经被GC，准备清理SoftReference对象
Heap
 PSYoungGen      total 2048K, used 45K [0x00000000ffd80000, 0x0000000100000000, 0x0000000100000000)
  eden space 1536K, 2% used [0x00000000ffd80000,0x00000000ffd8b7b8,0x00000000fff00000)
  from space 512K, 0% used [0x00000000fff80000,0x00000000fff80000,0x0000000100000000)
  to   space 512K, 0% used [0x00000000fff00000,0x00000000fff00000,0x00000000fff80000)
 ParOldGen       total 5632K, used 4755K [0x00000000ff800000, 0x00000000ffd80000, 0x00000000ffd80000)
  object space 5632K, 84% used [0x00000000ff800000,0x00000000ffca4d70,0x00000000ffd80000)
 Metaspace       used 3476K, capacity 4500K, committed 4864K, reserved 1056768K
  class space    used 382K, capacity 388K, committed 512K, reserved 1048576K

当我们想检测一个对象是否被回收了，那么我们就可以采用 Reference + ReferenceQueue，大概需要几个步骤：

2.Reference

Reference是四种引用类型的父类
因为Reference对象和垃圾回收密切配合实现，该类可能不能被直接子类化。
可以理解为Reference的直接子类都是由jvm定制化处理的,因此在代码中直接继承于Reference类型没有任何作用。但可以继承jvm定制的Reference的子类。
例如：Cleaner 继承了 PhantomReference

public class Cleaner extends PhantomReference<Object>

当我们想检测一个对象是否被回收了，那么我们就可以采用 Reference + ReferenceQueue，大概需要几个步骤：

• 创建一个引用队列 queue
• 创建 Reference 对象，并关联引用队列 queue
• 在 reference 被回收的时候，Reference 会被添加到 queue 中

3.总结:

Reference 和引用队列 ReferenceQueue 联合使用时，如果 Reference 持有的对象被垃圾回收，Java 虚拟机就会把这个弱引用加入到与之关联的引用队列中。