概述

使用了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);
        }
    }
}
posted on 2018-06-11 11:44  j.liu&nbsp;windliu  阅读(980)  评论(0编辑  收藏  举报