概述
Java的引用分为StrongReference、SoftReference、WeakReference、PhantomReference和FinalReference;
其中StrongRference并没有定义成接口,而其余四种都有相应的接口定义;
这五种引用的使用场景如下:
- 强引用
最普遍的引用。如果一个对象具有强引用,垃圾回收器绝不会回收它。当内存空 间不足,Java虚拟机宁愿抛出OutOfMemoryError错误,使程序异常终止,也不会靠随意回收具有强引用的对象来解决内存不足问题。 - 软引用
如果内存空间足,则不回收;如果内存空间不足,则会被回收;通常可以用来做为缓存; - 弱引用
一旦发生GC,弱引用对象立即被回收; - 虚引用
虚引用不会影响对象的生命周期。如果一个对象仅持有虚引用,那么它就和没有任何引用一样,在任何时候都可能被垃圾回收;
SoftReference和WeakReference
上面提到SoftReference适合用来实现缓存,例如google的guava cache就使用到了WeakReference和SoftReference,在创建cache时可以通过如下方式指定用哪种引用:
//使用WeakReference
CacheBuilder.newBuilder()
.maximumSize(10000)
.expireAfterWrite(10, TimeUnit.MINUTES).weakKeys().weakValues()
.build();
//使用SoftReference
CacheBuilder.newBuilder()
.maximumSize(10000)
.expireAfterWrite(10, TimeUnit.MINUTES).softValues()
.build();
创建SoftReference和WeakReference的构造函数如下:
public WeakReference(T referent, ReferenceQueue q) {
super(referent, q);
}
可以看到可以传入一个ReferenceQueue对象,那么这个传入到Queue对象到底有什么用呢?如果WeakReference所引用的对象被垃圾回收,Java虚拟机就会把这个WeakReference加入到与之关联的Queue中;
PhantomReference
DirectByteBuffer是JDK提供的堆外内存对象,其构造函数如下:
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;
}
其中的Cleaner对象继承自PhantomReference:
public class Cleaner extends PhantomReference
那么定义成PhantomReference起什么作用呢?其实主要是为了回收堆外内存,关于其具体的实现,后面会进行介绍;
FinalReference
FinalReference有个子类Finalizer,这两个类的包访问级别都是default而不是public的,因此我们无法在代码中直接调用;
说到FinalReference的使用,就免不了谈及对象的创建:
instanceOop InstanceKlass::allocate_instance(TRAPS) {
bool has_finalizer_flag = has_finalizer(); //判断当前类是否包含非空的finalize方法
int size = size_helper(); //确定要分配的内存大小
KlassHandle h_k(THREAD, this);
instanceOop i;
i = (instanceOop)CollectedHeap::obj_allocate(h_k, size, CHECK_NULL);
if (has_finalizer_flag && !RegisterFinalizersAtInit) {
i = register_finalizer(i, CHECK_NULL);
}
return i;
}
instanceOop InstanceKlass::register_finalizer(instanceOop i, TRAPS) {
if (TraceFinalizerRegistration) {
tty->print("Registered ");
i->print_value_on(tty);
tty->print_cr(" (" INTPTR_FORMAT ") as finalizable", (address)i);
}
instanceHandle h_i(THREAD, i);
// Pass the handle as argument, JavaCalls::call expects oop as jobjects
JavaValue result(T_VOID);
JavaCallArguments args(h_i);
methodHandle mh (THREAD, Universe::finalizer_register_method());
JavaCalls::call(&result, mh, &args, CHECK_NULL);
return h_i();
}
可以看到对象创建时,如果发现对象实现了finalize方法,则会调用Finalizer.register方法,将对象注册到Finalizer的静态属性unfinalized上,形成Finalizer链表;
final class Finalizer extends FinalReference
可以看到FinalizerThread线程会从queue队列中获取Finalizer对象,调用其finalize方法;queue即创建Reference时传入的queue对象;
那么,Finalizer什么时候会加入到queue队列呢?很容易想到,当GC发生时,Finalizer对象会加入到queue队列;
那么JVM是如何实现当对象回收时,将对象添加到queue呢?
# Reference
Reference对象是上述对象的基类,它的结构如下:
private T referent;
volatile ReferenceQueue queue;//对象被回收后,Reference会被放入队列
Reference next;
transient private Reference discovered; /* used by VM */
private static Reference pending = null;//JVM GC时,会将Reference对象设置到pending上,discovered相当于next,指向下一个Reference对象
static boolean tryHandlePending(boolean waitForNotify) {
Reference r;
Cleaner c;
try {
synchronized (lock) {
if (pending != null) {
r = pending;
c = r instanceof Cleaner ? (Cleaner) r : null;
pending = r.discovered;
r.discovered = null;
} else {
if (waitForNotify) {//如果等待,则调用lock.wait方法,当GC时将Reference添加到pending队列时,会调用lock.notify方法,
lock.wait();
}
return waitForNotify;
}
}
} catch (OutOfMemoryError x) {
Thread.yield();
return true;
} catch (InterruptedException x) {
return true;
}
if (c != null) {//如果是Cleaner对象,调用其clean方法释放资源
c.clean();
return true;
}
ReferenceQueue q = r.queue;
if (q != ReferenceQueue.NULL) q.enqueue(r);
return true;
}
前面提到的DirectByteBuffer内存的释放就是通过JVM GC时将对象添加到pending对象,而Reference中的ReferenceHandler线程会将pending中的对象添加到ReferenceQueue,同时如果发现是Cleaner对象,会调用clean方法释放堆外内存;
对于Finalizer对象,当被添加到ReferenceQueue时,会通过FinalizerThread线程调用finalize方法;因此可以看到Finalizer对象至少要经历两次垃圾回收才能被回收,同时由于FinalizerThread线程的优先级为Thread.MAX_PRIORITY - 2,因此当系统压力较大时,Finalizer对象可能要很久才能被回收;