Java中的强-软-弱-虚引用

Food food = new Food();//创建了Food对象，并保存了Food对象的强引用food

Food food = new Food();
SoftReference<Food> softFood = new SoftReference<>(food);
food = null;//此时通过第一句代码创建的Food对象是软引用可达的，假设此时JVM中可使用堆内存充足
System.gc();//建议JVM进行GC操作。即使建议被采纳，真的进行了GC操作，由于此时堆内存充足，softFood所引用的对象对应的堆内存也不会被回收
food = softFood.get();//仍然可以获取到原来的对象

Food food = new Food();
WeakReference<Food> weakFood = new WeakReference<>(food);
food = null;//此时通过第一句代码创建的Food对象是弱引用可达的
//建议JVM进行GC操作。假设建议被采纳，真的进行了GC操作，不管此时堆内存是否充足，
//weakFood所引用的对象对应的堆内存都会尝试被回收，至于回收是否成功，通过weakFood并不能得知
System.gc();
food = weakFood.get();//此时get方法返回的对象为null

ReferenceQueue<Object> queue = new ReferenceQueue<>();
Food food = new Food();
PhantomReference<Food> phantomFood = new PhantomReference<>(food, queue);
food = null;//此时通过第一句代码创建的Food对象是虚引用可达的
System.gc();//建议JVM进行GC操作。假设建议被采纳，真的进行了GC操作，不管此时堆内存是否充足，phantomFood所引用的对象对应的堆内存都会尝试被回收
Thread.sleep(10000);
if((phantomFood = queue.poll()) != null) {
	//第三句代码中创建的虚引用入队代表此虚引用引用的对象对应的堆内存此时可以被回收

	//在当前对象确定满足被回收条件之后可以进行一些其它操作，比如food对象比较大，为了防止内存泄漏，我们想做到在前一个food对象确定可以被GC回收时才创建下一个对象
	···

	phantomFood.clear();//对于虚引用，要手动调用clear方法确保其引用的对象对应的堆内存可以真正被回收
} 

public class SaveSelfInFinalize {

    private static SaveSelfInFinalize SAVE_HOOK = null;

    public static void main(String[] args) throws InterruptedException {
        SAVE_HOOK = new SaveSelfInFinalize();

        //第一次GC，在finalize方法中SAVE_HOOK对象会自救，重新关联到GC Roots
        SAVE_HOOK = null;
        System.gc();
        Thread.sleep(1000);//finalize方法优先级很低，暂停1s以等待其执行
        isAlive(SAVE_HOOK);

        //第二次GC，由于SAVE_HOOK对象的finalize方法已经被触发过一次，本次不会再触发
        SAVE_HOOK = null;
        System.gc();
        Thread.sleep(1000);//finalize方法优先级很低，暂停1s以等待其执行
        isAlive(SAVE_HOOK);
    }

    private static void isAlive(Object o) {
        if (o != null)
            System.out.println("yes, alive");
        else
            System.out.println("no, dead");
    }

    @Override
    protected void finalize() throws Throwable {
        try {
            System.out.println("finalize executed!");
            SAVE_HOOK = this;
        } finally {
            super.finalize();
        }
    }

}

输出结果：
	finalize executed!
	yes, alive
	no, dead

private static class Null<S> extends ReferenceQueue<S> {
	//覆盖父类的enqueue方法
    boolean enqueue(Reference<? extends S> r) {
        return false;
    }
}
static ReferenceQueue<Object> NULL = new Null<>();
static ReferenceQueue<Object> ENQUEUED = new Null<>();
//引用入队相关代码
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;
		//重点在这一句，入队之后会将此引用持有的队列引用置为Reference.ENQUEUED，此Reference之后再次调用enqueue方法尝试入队
		//调用的实际是子类Null的enqueue方法，会直接返回false
        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;
    }
}
//引用出队相关代码
public Reference<? extends T> poll() {
    if (head == null)
        return null;
    synchronized (lock) {
        return reallyPoll();//实际调用reallyPoll方法完成出队操作
    }
}
private Reference<? extends T> reallyPoll() {       /* Must hold lock */
    Reference<? extends T> r = head;
    if (r != null) {
        head = (r.next == r) ?
            null :
            r.next; // Unchecked due to the next field having a raw type in Reference
		//这句代码是重点，引用出队之后会将其持有的引用队列置为ReferenceQueue.NULL,下次再次尝试入队时调用的实际是
		//子类Null的enqueue方法，会直接返回false
        r.queue = NULL;
        r.next = r;
        queueLength--;
        if (r instanceof FinalReference) {
            sun.misc.VM.addFinalRefCount(-1);
        }
        return r;
    }
    return null;
}

class TestFinalize {

    private String name;

    public TestFinalize(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

}

public class PhantomReferenceAndFinalize {

    private final static ReferenceQueue<TestFinalize> queue = new ReferenceQueue<>();

    public static void main(String[] args) throws InterruptedException, NoSuchFieldException, IllegalAccessException {
        TestFinalize tf1 = new TestFinalize("tf1");
        PhantomReference<TestFinalize> pr = new PhantomReference<>(tf1, queue);
        System.out.println("before gc; pr: " + pr.getClass().getName() + " " + pr.hashCode());
        System.out.println("before gc; tf1: " + tf1.getClass().getName() + " " + tf1.hashCode());
        tf1 = null;
        System.gc();
        Thread.sleep(5000);
        Object pr1;
        if ((pr1 = queue.poll()) != null) {
            System.out.println("after gc; pr1: " + pr1.getClass().getName() + " " + pr1.hashCode());
        }
        Field referent = Reference.class.getDeclaredField("referent");
        referent.setAccessible(true);
        Object o = referent.get(pr1);
        if (o != null) {
            System.out.println("after gc; o: " + o.getClass().getName() + " " + o.hashCode());
        }
        System.out.println("pr1 == pr ? " + (pr1 == pr));
    }

}
//通过输出结果证明虚引用入队之后仍持有对referent对象的引用
输出结果：
	before gc; pr: java.lang.ref.PhantomReference 2001049719
	before gc; tf1: com.IOTest.TestFinalize 1528902577
	after gc; pr1: java.lang.ref.PhantomReference 2001049719
	after gc; o: com.IOTest.TestFinalize 1528902577
	pr1 == pr ? true

ByteBuffer bb = ByteBuffer.allocateDirect(1024 * 1024 * 8);
((DirectBuffer) bb).cleaner().clean();

class DirectByteBuffer extends MappedByteBuffer implements DirectBuffer
{
	···
	private static class Deallocator implements Runnable
	{
	
	    private static Unsafe unsafe = Unsafe.getUnsafe();
	    private long address;
	    private long size;
	    private int capacity;
	
	    private Deallocator(long address, long size, int capacity) {
	        assert (address != 0);
	        this.address = address;
	        this.size = size;
	        this.capacity = capacity;
	    }
	
	    public void run() {
	        if (address == 0) {
	            // Paranoia
	            return;
	        }
	        unsafe.freeMemory(address);
	        address = 0;
	        Bits.unreserveMemory(size, capacity);
	    }
	
	}

	DirectByteBuffer(int cap) {                   // package-private
	    super(-1, 0, cap, cap);
	    boolean pa = VM.isDirectMemoryPageAligned();
	    int ps = Bits.pageSize();
	    long size = Math.max(1L, (long)cap + (pa ? ps : 0));
		//当检测到分配出去的直接内存大小达到阈值时，在reserveMemory方法中调用System.gc建议回收已经不用的直接内存
	    Bits.reserveMemory(size, cap);
	
	    long base = 0;
	    try {
	        base = unsafe.allocateMemory(size);//此句为真正为其分配直接内存
	    } catch (OutOfMemoryError x) {
	        Bits.unreserveMemory(size, cap);
	        throw x;
	    }
	    unsafe.setMemory(base, size, (byte) 0);
	    if (pa && (base % ps != 0)) {
	        // Round up to page boundary
	        address = base + ps - (base & (ps - 1));
	    } else {
	        address = base;
	    }
		//为此DirectBuffer对象关联一个Cleaner，在此对象虚可达时调用cleaner对象的clean方法回收直接内存
		//回收内存的具体操作由Deallocator的run方法指定
	    cleaner = Cleaner.create(this, new Deallocator(base, size, cap));
	    att = null;
	}
	···
}

//Cleaner类是PhantomReference类的子类，当referent虚可达时，它的clean方法会被调用，执行指定的任务
public class Cleaner extends PhantomReference<Object> {
	···
}
//当将一个Reference类对象由Pending状态变为Enqueued状态时，如果此Reference类对象是一个Cleaner类的对象，ReferenceHandler线程中运行的tryHandlePending()方法调用Cleaner的clean方法完成堆外内存的清理操作。
public abstract class Reference<T> {
	static boolean tryHandlePending(boolean waitForNotify) {
        Reference<Object> r;
        Cleaner c;
        try {
            synchronized (lock) {
                if (pending != null) {
                    r = pending;
                    // 'instanceof' might throw OutOfMemoryError sometimes
                    // so do this before un-linking 'r' from the 'pending' chain...
                    c = r instanceof Cleaner ? (Cleaner) r : null;
                    // unlink 'r' from 'pending' chain
                    pending = r.discovered;
                    r.discovered = null;
                } else {
                    // The waiting on the lock may cause an OutOfMemoryError
                    // because it may try to allocate exception objects.
                    if (waitForNotify) {
                        lock.wait();
                    }
                    // retry if waited
                    return waitForNotify;
                }
            }
        } catch (OutOfMemoryError x) {
            // Give other threads CPU time so they hopefully drop some live references
            // and GC reclaims some space.
            // Also prevent CPU intensive spinning in case 'r instanceof Cleaner' above
            // persistently throws OOME for some time...
            Thread.yield();
            // retry
            return true;
        } catch (InterruptedException x) {
            // retry
            return true;
        }

        // Fast path for cleaners
        if (c != null) {
            c.clean();
            return true;
        }

        ReferenceQueue<? super Object> q = r.queue;
        if (q != ReferenceQueue.NULL) q.enqueue(r);
        return true;
    }
}

public class UnsafeUtil {
    private static class UnsafeHolder {
        private static Unsafe unsafe;

        static {
            Field field = Unsafe.class.getDeclaredFields()[0];
            field.setAccessible(true);
            try {
                unsafe = (Unsafe) field.get(null);
            } catch (IllegalAccessException e) {
                throw new RuntimeException(e);
            }
        }
    }

    public static Unsafe getUnsafeInstance() {
        return UnsafeHolder.unsafe;
    }
}

public class MyCleaner {
    private static ReferenceQueue<Object> refQueue = new ReferenceQueue<>();
    private static Map<Reference<Object>, Runnable> refMap = new ConcurrentHashMap<>();

    static {
        new Thread(new CleanerThread()).start();
    }

    public static void makeCleanRelation(Object o, Runnable task) {
        Reference<Object> ref = new PhantomReference<>(o, refQueue);
        refMap.put(ref, task);
    }

    private static class CleanerThread implements Runnable {
        private Reference<Object> tempRef;

        @Override
        public void run() {
            while (true) {
                if ((tempRef = (Reference<Object>) refQueue.poll()) != null) {
					tempRef.clear();//clear之后或者tempRef不可达时，虚引用指向的referent对象对应的堆内内存才能被回收。
                    Runnable task = refMap.remove(tempRef);
                    new Thread(task).start();
                }
            }
        }
    }
}

public class FreeMemoryTask implements Runnable {
    private long address = 0;

    public FreeMemoryTask(long address)
    {
        this.address = address;
    }

    @Override
    public void run()
    {
        System.out.println("runing FreeMemoryTask");
        if (address == 0)
        {
            System.out.println("already released");
        } else
        {
            UnsafeUtil.getUnsafeInstance().freeMemory(address);
        }
    }
}

public class Test {
    private static final int _1MB = 1024 * 1024;
    private long address = 0;

    public Test() {
        address = UnsafeUtil.getUnsafeInstance().allocateMemory(8 * _1MB);
    }

    public static void main(String[] args) {
        while (true) {
            System.out.println("分配内存");
            Test test = new Test();
            MyCleaner.makeCleanRelation(test, new FreeMemoryTask(test.address));
            test = null;
            System.gc();
        }
    }
}