最近在查一個堆外內存泄露的問題，順便學習了下MaxDirectMemorySize使用。
總所周知-XX:MaxDirectMemorySize可以設置java堆外內存的峰值，但是具體是在哪里限制的呢，來跟蹤下創建DirectByteBuffer的過程。
找到DirectByteBuffer的構造函數
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;
}
主要代碼：
- Bits.reserveMemory(size, cap);檢測是否足夠分配空間，并增加內部總量計數器
- unsafe.allocateMemory(size); 通過Unsafe類分配內存地址
- cleaner = Cleaner.create(this, new Deallocator(base, size, cap));創建清理類，用于內存回收
java.nio.Bits
// These methods should be called whenever direct memory is allocated or
// freed. They allow the user to control the amount of direct memory
// which a process may access. All sizes are specified in bytes.
static void reserveMemory(long size, int cap) {
//因為內存分配是全局的，所以必須加鎖
synchronized (Bits.class) {
if (!memoryLimitSet && VM.isBooted()) {
maxMemory = VM.maxDirectMemory(); //最大堆外內存設置
memoryLimitSet = true;
}
// -XX:MaxDirectMemorySize limits the total capacity rather than the
// actual memory usage, which will differ when buffers are page
// aligned.
//如果剩余空間足夠，增加總量計數器直接返回
if (cap <= maxMemory - totalCapacity) {
reservedMemory += size;
totalCapacity += cap;
count++;
return;
}
}
//如果剩余空間不足，那么先執行一次GC
System.gc();
try {
Thread.sleep(100);//其實jvm也用了很low的sleep下，等待GC完成
} catch (InterruptedException x) {
// Restore interrupt status
Thread.currentThread().interrupt();
}
//這里同樣，在計算的時候必須是同步的
synchronized (Bits.class) {
//如果內存空間還是不夠，則拋出異常
if (totalCapacity + cap > maxMemory)
throw new OutOfMemoryError("Direct buffer memory");
reservedMemory += size;
totalCapacity += cap;
count++;
}
}
在GC的時候totalCapacity會被釋放，看下具體實現。
在DirectByteBuffer中的內部類Deallocator：
...省略
public void run() {
if (address == 0) {
// Paranoia
return;
}
unsafe.freeMemory(address);//釋放內存
address = 0;
Bits.unreserveMemory(size, capacity);//回收totalCapacity
}
...省略
java.nio.Bits:
//減少使用內存總量的計數器
static synchronized void unreserveMemory(long size, int cap) {
if (reservedMemory > 0) {
reservedMemory -= size;
totalCapacity -= cap;
count--;
assert (reservedMemory > -1);
}
}
Deallocator在DirectByteBuffer的構造函數中：
DirectByteBuffer(int cap) { // package-private
...省略
cleaner = Cleaner.create(this, new Deallocator(base, size, cap));
...省略
}
我們來仔細看下Cleaner對象：
...省略部分代碼
public class Cleaner extends PhantomReference<Object> {
public static Cleaner create(Object var0, Runnable var1) {
return var1 == null?null:add(new Cleaner(var0, var1));
}
private static synchronized Cleaner add(Cleaner var0) {
if(first != null) {
var0.next = first;
first.prev = var0;
}
first = var0;
return var0;
}
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;
}
});
}
}
}
}
Cleaner繼承了虛引用，并且內部是一個雙向鏈表，每次create時添加到表頭。
虛引用簡單來講就是在GC時，將對象放入ReferenceQueue中，具體的可以搜索相關知識，再看執行Deallocator線程的clean函數，找到調用的地方：
public abstract class Reference<T> {
...省略部分代碼
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 {
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);
}
}
}
static {
ThreadGroup tg = Thread.currentThread().getThreadGroup();
for (ThreadGroup tgn = tg;
tgn != null;
tg = tgn, tgn = tg.getParent());
Thread handler = new ReferenceHandler(tg, "Reference Handler");
/* If there were a special system-only priority greater than
* MAX_PRIORITY, it would be used here
*/
handler.setPriority(Thread.MAX_PRIORITY);
handler.setDaemon(true);
handler.start();
}
}
ReferenceHandler是全局的守護線程，用于將虛引用的對象添加到ReferenceQueue中
看到在ReferenceHandler中enqueue前，會先檢測Cleaner對象，并且這里continue了，也就是說Cleaner對象不會像普通的虛引用一樣放入ReferenceQueue中。
所以可以理解為Cleaner使用虛引用為的是利用ReferenceHandler線程在gc時釋放堆外內存。
