结论:堆外内存只有在fullgc的时候才能够回收掉。
构造函数:主要看三个地方,一个是Bits.reserverMemory 一个是unsafe.allocateMemory 一个是 Cleaner.create。Bits主要是记录了堆外内存的使用情况和最大容量。
DirectByteBuffer(int cap) {
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;
}
1.1.1:reserveMemory分配内存,主要逻辑在tryReserveMemory里面,如果分配失败了,会尝试回收内存再分配,还失败就调用System.gc,然后再分配,如果还是失败就会抛出异常
static void reserveMemory(long size, int cap) {
if (!memoryLimitSet && VM.isBooted()) {
maxMemory = VM.maxDirectMemory();
memoryLimitSet = true;
}
// 如果能够分配
if (tryReserveMemory(size, cap)) {
return;
}
// 分配失败了
final JavaLangRefAccess jlra = SharedSecrets.getJavaLangRefAccess();
// retry while helping enqueue pending Reference objects
// which includes executing pending Cleaner(s) which includes
// Cleaner(s) that free direct buffer memory
// 尝试回收
while (jlra.tryHandlePendingReference()) {
if (tryReserveMemory(size, cap)) {
return;
}
}
// trigger VM's Reference processing
// 如果还是失败,触发gc(只是建议jvm gc)
System.gc();
// a retry loop with exponential back-off delays
// (this gives VM some time to do it's job)
// 循环几次 休息1ms(让出cpu 等待jvm gc),尝试分配,尝试10次后报错
boolean interrupted = false;
try {
long sleepTime = 1;
int sleeps = 0;
while (true) {
if (tryReserveMemory(size, cap)) {
return;
}
if (sleeps >= MAX_SLEEPS) {
break;
}
if (!jlra.tryHandlePendingReference()) {
try {
Thread.sleep(sleepTime);
sleepTime <<= 1;
sleeps++;
} catch (InterruptedException e) {
interrupted = true;
}
}
}
// no luck
throw new OutOfMemoryError("Direct buffer memory");
} finally {
if (interrupted) {
// don't swallow interrupts
Thread.currentThread().interrupt();
}
}
}
1.1.2:tryReserveMemory具体的逻辑,就Bits不是实际分配内存的地方,它只是比较一下容量有没有超过设置的最大容量。
private static boolean tryReserveMemory(long size, int cap) {
// -XX:MaxDirectMemorySize limits the total capacity rather than the
// actual memory usage, which will differ when buffers are page
// aligned.
long totalCap;
// 看看有没有超过最大容量 这里没有根据实际的内存做判断
// 也就是说你把-XX:MaxDirectMemorySize设置的很大,不会触发gc
// 后面系统实际分配不了会抛oom
while (cap <= maxMemory - (totalCap = totalCapacity.get())) {
if (totalCapacity.compareAndSet(totalCap, totalCap + cap)) {
reservedMemory.addAndGet(size);
count.incrementAndGet();
return true;
}
}
return false;
}
1.2.1:unsafe.allocateMemory,这是一个本地方法,负责实际的分配内存。如果实际内存不够分配,会抛出异常。
1.3.1:Cleaner.create。这个是创建一个cleaner对象,这是一个虚引用,指向了DirectByteBuffer对象本身。在DirectByteBuffe对象被回收时,这个cleaner对象会被jvm加入到引用队列,jvm会有专门的线程(Reference类的静态块起了一个线程,用来不停的清理引用队列。)处理这个队列,如果发现是cleaner对象,就会调用cleaner.clean。而在cleaner构建的时候绑定了一个清理任务。最后调用的是unsafe.freeMemory(address)释放内存,这也是一个本地方法。
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;
// 绑定的runable
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) {
// 调用add 加入列表,绑定了一个清理器
return var1 == null ? null : add(new Cleaner(var0, var1));
}
public void clean() { // clean方法就是调用绑定的runnable.run
if (remove(this)) {
try {
this.thunk.run();
} catch (final Throwable var2) {
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
if (System.err != null) {
(new Error("Cleaner terminated abnormally", var2)).printStackTrace();
}
System.exit(1);
return null;
}
});
}
}
}
}
最后看一下如何处理引用队列。(当对象被回收时,如果含有虚引用就会把虚引用加入pending)
static boolean tryHandlePending(boolean var0) {
Reference var1;
Cleaner var2;
try {
synchronized(lock) {
if (pending == null) {
if (var0) {
lock.wait();
}
return var0;
}
// jvm回收时,会把虚引用放入pending
var1 = pending;
// 判断是不是cleaner类型
var2 = var1 instanceof Cleaner ? (Cleaner)var1 : null;
pending = var1.discovered;
var1.discovered = null;
}
} catch (OutOfMemoryError var6) {
Thread.yield();
return true;
} catch (InterruptedException var7) {
return true;
}
// 如果是cleaner类型 调用clean方法
if (var2 != null) {
var2.clean();
return true;
} else {
ReferenceQueue var3 = var1.queue;
if (var3 != ReferenceQueue.NULL) {
var3.enqueue(var1);
}
return true;
}
}
总结: