nio DirectByteBuffer如何回收堆外内存

概述

使用了nio框架的应用，比如服务框架，利用nio建立长连接通信，他们会使用DirectByteBuffer来分配堆外内存，也就是本地直接内存，这个内存的回收不由gc直接维护，我们通常所说的gc，只回收jvm的堆、方法区。本地内存如果没有用jvm启动参数手动指定，它会根据主机的剩余可用内存进行分配，如果说一个机器的8G内存的，其中，我们手动指定的jvm堆、方法区内存为2048 + 256，那么，除了其他进程占用的内存，剩余的可用内存可能是较大的。如果你的主机有内存使用量监控（不是jvm级的内存监控），在使用类似Netty这种通信框架时，有可能会触发主机内存使用率报警。

堆外内存回收方法

• 首先强调，gc不会直接回收堆外内存，堆外内存如果不通过启动参数指定，会根据主机的剩余可用内存来作为容量，这有可能是一块很大的内存，gc回收代价可能较大

• DirectByteBuffer对象在堆内生成时，会和一个RefereceQueue建立虚引用联系，这里是通过Cleaner对象的某个field被赋值为DirectByteBuffer对象来建立虚引用的，注意，这里是Cleaner对象虚引用了DirectByteBuffer对象，引用queue为cleaner中的dummyQueue。再次强调，cleaner对象虽然虚引用了DirectByteBuffer，但是垃圾回收在计算对象可达性时，会忽略Cleaner对的DirectByteBuffer虚引用，DirectByteBuffer只有可以，就可以立即回收，无视Cleaner对象当前是存活状态。

• jdk实现GC时，对几种引用类型有定制化开发，在对象B被回收后，会通知到一个ReferenceHandler线程，获取到虚引用对象A，判断A是否是Cleaner，如果是就会调用Cleaner.clean()方法，获取DirectByteBuffer被分配的堆外内存地址，释放B在堆外内存开辟的空间，释放内存

    class DirectByteBuffer{
    	// Primary constructor
    	//
    	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));
    		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;
    		}
    		cleaner = Cleaner.create(this, new Deallocator(base, size, cap));
    		att = null;
  
    	}
              ...
     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);
    	}
  
    }
    ...
    }
  

Clean类，runnable这里对应Deallocator类型

package sun.misc;

import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;
import java.security.AccessController;
import java.security.PrivilegedAction;

public class Cleaner extends PhantomReference<Object> {
	private static final ReferenceQueue<Object> dummyQueue = new ReferenceQueue();
	private static Cleaner first = null;
	private Cleaner next = null;
	private Cleaner prev = null;
	private final Runnable thunk;

	private static synchronized Cleaner add(Cleaner var0) {
		if(first != null) {
			var0.next = first;
			first.prev = var0;
		}

		first = var0;
		return var0;
	}

	private static synchronized boolean remove(Cleaner var0) {
		if(var0.next == var0) {
			return false;
		} else {
			if(first == var0) {
				if(var0.next != null) {
					first = var0.next;
				} else {
					first = var0.prev;
				}
			}

			if(var0.next != null) {
				var0.next.prev = var0.prev;
			}

			if(var0.prev != null) {
				var0.prev.next = var0.next;
			}

			var0.next = var0;
			var0.prev = var0;
			return true;
		}
	}

	private Cleaner(Object var1, Runnable var2) {
		super(var1, dummyQueue);
		this.thunk = var2;
	}

	public static Cleaner create(Object var0, Runnable var1) {
		return var1 == null?null:add(new Cleaner(var0, var1));
	}

	public void clean() {
		if(remove(this)) {
			try {
				this.thunk.run();
			} catch (final Throwable var2) {
				AccessController.doPrivileged(new PrivilegedAction() {
					public Void run() {
						if(System.err != null) {
							(new Error("Cleaner terminated abnormally", var2)).printStackTrace();
						}

						System.exit(1);
						return null;
					}
				});
			}

		}
	}
}

当jvm回收掉DirectByteBuffer后，会将虚引用它的对象Cleaner入队ReferenceHandler中会消费的队列，同时ReferenceHandler线程发现新来了一个虚引用对象，会判断这个对象否为Cleaner，如果是，则会执行clean()方法，达到回收的目的

    /* High-priority thread to enqueue pending References
 */
private static class ReferenceHandler extends Thread {

    ReferenceHandler(ThreadGroup g, String name) {
        super(g, name);
    }

    public void run() {
        for (;;) {
            Reference<Object> r;
            synchronized (lock) {
                if (pending != null) {
                    r = pending;
                    pending = r.discovered;
                    r.discovered = null;
                } else {
                    // The waiting on the lock may cause an OOME because it may try to allocate
                    // exception objects, so also catch OOME here to avoid silent exit of the
                    // reference handler thread.
                    //
                    // Explicitly define the order of the two exceptions we catch here
                    // when waiting for the lock.
                    //
                    // We do not want to try to potentially load the InterruptedException class
                    // (which would be done if this was its first use, and InterruptedException
                    // were checked first) in this situation.
                    //
                    // This may lead to the VM not ever trying to load the InterruptedException
                    // class again.
                    try {
                        try {
                            lock.wait();
                        } catch (OutOfMemoryError x) { }
                    } catch (InterruptedException x) { }
                    continue;
                }
            }

            // Fast path for cleaners
            if (r instanceof Cleaner) {
                ((Cleaner)r).clean();
                continue;
            }

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