详解 Java 中的四种引用

public class Main {

	// 引用测试类
	static class ReferenceTest {
		static final int _1M = 1024;
        // 引用队列，当某个引用所指向的对象被回收时这个引用本身会被添加到其对应的引用队列中
        // 其泛型为其中存放的引用要指向的对象类型
		ReferenceQueue<Object> referenceQueue = new ReferenceQueue<>();

		// 强引用测试
		void testStrongReference() {
			ArrayList<byte[]> strongReferences = new ArrayList<>();
			try {
				while (true) {
					strongReferences.add(new byte[_1M]);
				}
			} catch (OutOfMemoryError e) {
				e.printStackTrace();
			}
		}

		// 软引用测试
		void testSoftReference() {
			ArrayList<SoftReference> softReferences = new ArrayList<>();
			try {
				while (true) {
					softReferences.add(new SoftReference<>(new byte[_1M], referenceQueue));
				}
			} catch (OutOfMemoryError e) {
				e.printStackTrace();
			}
		}

		// 弱引用测试
		void testWeakReference() {
			ArrayList<WeakReference> weakReferences = new ArrayList<>();
			try {
				while (true) {
					weakReferences.add(new WeakReference<>(new byte[_1M], referenceQueue));
				}
			} catch (OutOfMemoryError e) {
				e.printStackTrace();
			}
		}

		// 虚引用测试
		void testPhantomReference() {
			ArrayList<PhantomReference<byte[]>> phantomReferences = new ArrayList<>();
			try {
				while (true) {
					phantomReferences.add(new PhantomReference<>(new byte[_1M], referenceQueue));
				}
			} catch (OutOfMemoryError e) {
				e.printStackTrace();
			}
		}
	}

	public static void main(String[] args) {
		ReferenceTest test = new ReferenceTest();
		test.testStrongReference();
	}
}

public class WeakReference<T> extends Reference<T> {
    
    public WeakReference(T referent) {
        super(referent);
    }

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

public abstract class Reference<T> {

    private T referent;         /* Treated specially by GC */

    volatile ReferenceQueue<? super T> queue;

    /* When active:   NULL
     *     pending:   this
     *    Enqueued:   next reference in queue (or this if last)
     *    Inactive:   this
     */
    @SuppressWarnings("rawtypes")
    Reference next; // 引用所处的状态不同时，该属性保存了不同的信息
    
	// ...
    
    /**
     * 获取当前引用所指向的对象的方法，如果所指向对象已经被 GC 回收，那么返回 null
     */
    public T get() {
        return this.referent;
    }

    /**
     * 清除该引用所指向的对象，该方法会在 GC 回收该引用指向的对象后被 GC 调用，
     * 之后，通过该引用对象的 get 方法得到的返回值为 null, 该方法不应该被程序员主动调用
     */
    public void clear() {
        this.referent = null;
    }

    /* -- Queue operations -- */

    /**
     * 判断当前引用是否已经进入对应的引用队列，
     * 如果构造该引用对象时没有指定对应的引用队列，那么该方法始终返回 false
     */
    public boolean isEnqueued() {
        return (this.queue == ReferenceQueue.ENQUEUED);
    }

    /**
     * 如果当前引用对象的引用队列属性（构造时由参数指定）不为 null, 
     * 那么当这个引用所指向的对象被 GC 回收之后会由 GC 调用这个方法，
     * 代表将该引用进入对应的引用队列（即该引用指向的对象被回收）
     */
    public boolean enqueue() {
        return this.queue.enqueue(this);
    }

    /* -- Constructors -- */
    Reference(T referent) {
        this(referent, null);
    }

    Reference(T referent, ReferenceQueue<? super T> queue) {
        this.referent = referent;
        this.queue = (queue == null) ? ReferenceQueue.NULL : queue;
    }
}

public class ReferenceQueue<T> {

    /**
     * Constructs a new reference-object queue.
     */
    public ReferenceQueue() { }

    // ...

    static private class Lock { };
    private Lock lock = new Lock();
    private volatile Reference<? extends T> head = null;
    private long queueLength = 0;

    // 引用对象本身入队列的过程就是一个向单向链表中插入节点的过程
    boolean enqueue(Reference<? extends T> r) { /* Called only by Reference class */
        synchronized (lock) { // 保证线程安全
            // Check that since getting the lock this reference hasn't already been
            // enqueued (and even then removed)
            ReferenceQueue<?> queue = r.queue;
            if ((queue == NULL) || (queue == ENQUEUED)) {
                return false;
            }
            assert queue == this;
            r.queue = ENQUEUED; // 更新引用入队状态
           	// 前插法插入链表节点
            r.next = (head == null) ? r : head;
            head = r;
            queueLength++;
            if (r instanceof FinalReference) {
                sun.misc.VM.addFinalRefCount(1);
            }
            lock.notifyAll();
            return true;
        }
    }

    /**
     * 返回当前引用队列中的第一个引用对象，如果不存在则返回 null
     * 该方法不会阻塞线程
     */
    public Reference<? extends T> poll() {
        if (head == null)
            return null;
        synchronized (lock) {
            return reallyPoll();
        }
    }

    /**
     * 返回当前引用队列中第一个可用的引用对象，如果没有，则阻塞线程一定时间（参数指定）
     * 阻塞时间过后，如果当前队列中仍然没有可用的引用对象，那么抛出中断异常（InterruptedException）
     */
    public Reference<? extends T> remove(long timeout)
        throws IllegalArgumentException, InterruptedException
    {
        if (timeout < 0) {
            throw new IllegalArgumentException("Negative timeout value");
        }
        synchronized (lock) {
            Reference<? extends T> r = reallyPoll();
            if (r != null) return r;
            long start = (timeout == 0) ? 0 : System.nanoTime();
            for (;;) {
                lock.wait(timeout);
                r = reallyPoll();
                if (r != null) return r;
                if (timeout != 0) {
                    long end = System.nanoTime();
                    timeout -= (end - start) / 1000_000;
                    if (timeout <= 0) return null;
                    start = end;
                }
            }
        }
    }

    /**
     * 阻塞调用线程，直到当前引用队列中存在可用的引用对象，将该引用对象从引用队列中移除并返回该引用对象
     */
    public Reference<? extends T> remove() throws InterruptedException {
        return remove(0);
    }
}

// 引用队列测试类
static class ReferenceQueueTest {

	ReferenceQueue<byte[]> referenceQueue = new ReferenceQueue<>();

	// 对象回收时的引用通知测试
	void testReferenceNotify() {
		WeakReference<byte[]> weakReference = new WeakReference<>(new byte[1024], referenceQueue);
            // 后面的 ReferenceQueue.remove 方法会阻塞调用线程，因此开子线程进行操作
		Thread thread = new Thread(() -> {
			try {
				for (Reference pr; (pr = referenceQueue.remove()) != null; ) {
					System.out.println(pr + " 引用所指向的对象被回收!");
				}
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		});
		/* 
		 因为 ReferenceQueue 对象的 remove 方法是阻塞线程的，因此子线程需设置守护线程，
		 否则如果 ReferenceQueue 中没有可取出的引用对象会导致线程一直阻塞，程序不能退出
		*/
		thread.setDaemon(true);
		thread.start();
		// 启动垃圾回收动作，将弱引用指向的对象回收
		System.gc();
	}
}