Java引用类型之弱引用与幻像引用

这一篇将介绍弱引用和幻像引用。

1、WeakReference

WeakReference也就是弱引用，弱引用和软引用类似，它是用来描述"非必须"的对象的，它的强度比软引用要更弱一些。被弱引用关联的对象只能生存到下一次垃圾收集发生之前，简言之就是：一旦发生GC必定回收被弱引用关联的对象，不管当前的内存是否足够。WeakReference类的定义如下：

public class WeakReference<T> extends Reference<T> {	
    public WeakReference(T referent) {	
        super(referent);	
    }	
    public WeakReference(T referent, ReferenceQueue<? super T> q) {	
        super(referent, q);	
    }	
}

WeakReference继承了Reference。在ReferenceProcessorStats ReferenceProcessor::process_discovered_references()方法中调用process_discovered_reflist()方法处理弱引用，如下：

// Weak references
size_t weak_count = 0;
{
    // 传递的clear_referent的值为true
    weak_count =  process_discovered_reflist(_discoveredWeakRefs, NULL, true,
                                 is_alive, keep_alive, complete_gc, task_executor);
}

调用的process_discovered_reflist()方法中会用后2个阶段处理弱引用，在之前已经介绍过，这里不再介绍。

2、PhantomReference

PhantomReference也就是幻像引用，它是所有引用类型中最弱的一种。一个对象是否关联到虚引用，完全不会影响该对象的生命周期，也无法通过虚引用来获取一个对象的实例。为对象设置一个虚引用的唯一目的是：能在此对象被垃圾收集器回收的时候收到一个系统通知。PhantomReference类的定义如下：

public class PhantomReference<T> extends Reference<T> {	
    public T get() {	
        return null;	
    }	
    public PhantomReference(T referent, ReferenceQueue<? super T> q) {	
        super(referent, q);	
    }	
}

可以看到幻像引用的get()方法永远返回null，所以也就无法通过虚引用来获取一个对象的实例。

public static void demo() throws InterruptedException {	
        Object                    obj = new Object();	
        ReferenceQueue<Object>    refQueue =new ReferenceQueue<>();	
        PhantomReference<Object>  phanRef =new PhantomReference<>(obj, refQueue);	
        Object                    objg = phanRef.get();	
        // 这里拿到的是null	
        System.out.println(objg);	
        // 让obj变成垃圾	
        obj=null;	
        System.gc();	
        Thread.sleep(3000);	
        // GC后会将phanRef加入到refQueue中	
        Reference<? extends Object> phanRefP = refQueue.remove();	
         //这里输出true	
        System.out.println(phanRefP==phanRef);	
}

从以上代码中可以看到，幻像引用能够在指向对象不可达时得到一个“通知”（其实所有继承Reference的类都有这个功能），需要注意的是GC完成后，phanRef.referent依然指向之前创建Object，也就是说Object对象一直没被回收！

而造成这一现象的原因在之前也介绍过：对于Finalreference和Phantomreference来说，clear_referent 字段传入的值为false，意味着被这两种引用类型引用的对象，如果没有其他额外处理，在GC中是不会被回收的。

对于幻像引用来说，从refQueue.remove()得到引用对象后，可以调用clear()方法强行解除引用和对象之间的关系，使得对象下次可以GC时可以被回收掉。

在ReferenceProcessor::process_discovered_references()方法中调用process_discovered_reflist()方法处理幻像引用，如下：

// Phantom references
size_t phantom_count = 0;
{
    // 传递的clear_referent的值为false
    phantom_count =  process_discovered_reflist(_discoveredPhantomRefs, NULL, false,
                                 is_alive, keep_alive, complete_gc, task_executor);
}

调用的process_discovered_reflist()方法中会用后2个阶段处理幻像引用，在之前已经介绍过，这里不再介绍。

3、Cleaner

PhantomReference有两个比较常用的子类，如下：

（1）java.lang.ref.Cleaner：开发者用于在引用对象回收的时候触发一个动作，在JDK 9中将完全替代Object.finalize()方法。

（2）jdk.internal.ref.Cleaner：用于DirectByteBuffer对象回收的时候对于堆外内存的回收。ReferenceHandler线程会对pending链表中的jdk.internal.ref.Cleaner类型引用对象调用其clean()方法。

对于java.lang.ref.Cleaner类来说，举个例子如下：

import java.lang.ref.Cleaner;
 
public class CleaningExample implements AutoCloseable {
	// A cleaner, preferably one shared within a library
	private static final Cleaner cleaner = Cleaner.create();
 
	static class State implements Runnable {
 		State() {
			System.out.println("init");// initialize State needed for cleaning action
		}
 
		public void run() {
			System.out.println("clean");// cleanup action accessing State, executed at most once
		}
	}
 
	private final State state;
	private final Cleaner.Cleanable cleanable;
 
	public CleaningExample() {
		this.state = new State();
		this.cleanable = cleaner.register(this, state);
	}
 
	public void close() {
		cleanable.clean();
	}
	
	public static void main(String[] args) {
		while(true) {
			new CleaningExample();
		}
	}
}

本例中每次创建对象时，都会打印init;回收对象时，都会打印clean。　　

下面介绍jdk.internal.ref.Cleaner类。

Cleaner继承自Java四大引用类型之一的幻像引用PhantomReference（众所周知，无法通过幻像引用获取与之关联的对象实例，且当对象仅被幻像引用引用时，在任何发生GC的时候，其均可被回收），通常PhantomReference与引用队列ReferenceQueue结合使用，可以实现幻像引用关联对象被垃圾回收时能够进行系统通知、资源清理等功能。如下图所示，当某个被Cleaner引用的对象将被回收时，JVM垃圾收集器会将此对象的引用放入到对象引用中的pending链表中，等待ReferenceHandler进行相关处理。其中，ReferenceHandler为一个拥有最高优先级的守护线程，会循环不断的处理pending链表中的对象引用，执行Cleaner的clean()方法进行相关清理工作，这在之前介绍ReferenceHandler类时介绍过，这里不再介绍。

Cleaner只有在清理逻辑足够轻量和直接的时候才适合使用Cleaner，繁琐耗时的清理逻辑将有可能导致ReferenceHandler线程阻塞从而耽误其它的清理任务。