堆(包括里面的StringConstantPool)存在垃圾回收机制
对象可以被回收的条件:
可达性分析算法
扫描堆中的所有对象,被GC Root对象直接或间接引用的需要保留
其他的可以被回收
GC Root对象:
虚拟机栈(栈帧中的本地变量表)中引用的对象
本地方法栈(Native方法)中引用的对象
方法区中类静态属性引用的对象
方法区中常量引用的对象
所有被同步锁持有的对象
软引用
/**
* Creates a new soft reference that refers to the given object. The new
* reference is not registered with any queue.
*
* @param referent object the new soft reference will refer to
*/
public SoftReference(T referent) {
super(referent);
this.timestamp = clock;
}
static final int _4MB = 4 * 1024 * 1024;
public static void main(String[] args) {
soft();
}
// 将堆内存调小-Xmx20m,调用这个方法
// 只有SoftReference引用(依赖)的对象,在gc后,仍要发生内存溢出,会二次gc,将这些对象清理,如果还不够,才会报OutOfMemory
// 第一次gc之后不会内存溢出,则不清理这些对象
private static void soft() {
// list --> SoftReference --> byte[]
List<SoftReference<byte[]>> list = new ArrayList<>();
for (int i = 0; i < 5; i++) {
SoftReference<byte[]> ref = new SoftReference<>(new byte[_4MB]);
list.add(ref); // 装第4个ref时内存不够用了,gc还是不行,就把前三个ref中byte[]指向的堆对象给清理掉了
System.out.println(ref.get());
}
System.out.println("======================");
for(SoftReference<byte[]> ref : list){
System.out.println(ref.get()); // 显示null表示被清理了
}
}
------------------------------------------------
将byte[]被回收了的那些SoftReference也清理掉
// 引用队列
ReferenceQueue<byte[]> queue = new ReferenceQueue<>();
// 关联了引用队列,SoftReference关联的byte[]被回收时,SoftReference自己会加入到队列中去
SoftReference<byte[]> ref = new SoftReference<>(new byte[_4MB],queue);
// 从list中清理掉那些无用的SoftReference
Reference<? extends byte[]> poll = queue.poll();
while(poll != null){
list.remove(poll);
poll = queue.poll();
}
弱引用
只具有弱引用的对象拥有更短暂的生命周期
对于只有WeakReference依赖的对象,gc时,会将其清理掉(无论当前内存是否充足)
private static void weak() {
WeakReference<Object> ref = new WeakReference<>(new Object());
System.out.println(ref.get());// java.lang.Object@52cc8049
System.gc();
System.out.println(ref.get());// null
}
private static void notWeak() {
Object o = new Object();// 变量o对堆中那个对象是强引用
WeakReference<Object> ref = new WeakReference<>(o);// 弱引用
System.out.println(ref.get());// java.lang.Object@52cc8049
System.gc();
System.out.println(ref.get());// java.lang.Object@52cc8049
}
private static void notWeak() {
Object o = new Object();// 变量o对堆中那个对象是强引用
WeakReference<Object> ref = new WeakReference<>(o);// 弱引用
System.out.println(ref.get());// java.lang.Object@52cc8049
System.gc();
System.out.println(ref.get());// java.lang.Object@52cc8049
o = null;// 不再有强引用
System.gc();
System.out.println(ref.get());// null
}
虚引用
必须配合ReferenceQueue使用
设置虚引用的唯一目的,就是在这个对象被gc时收到一个系统通知或者后续添加进一步的处理.
在虚引用引用的的对象被gc时,虚引用对象自己会进入引用队列
创建ByteBuffer类的对象时,会创建一个Cleaner虚引用对象public class Cleaner extends PhantomReference<Object>
当ByteBuffer被回收时,让虚引用对象Cleaner进入引用队列,ReferenceHandler线程会调用队列中的Cleaner的clean方法来释放直接内存
public static ByteBuffer allocateDirect(int capacity) {
return new DirectByteBuffer(capacity);
}
cleaner = Cleaner.create(this, new Deallocator(base, size, cap));
/**
* Creates a new cleaner.
*
* @param ob the referent object to be cleaned
* @param thunk
* The cleanup code to be run when the cleaner is invoked. The
* cleanup code is run directly from the reference-handler thread,
* so it should be as simple and straightforward as possible.
*
* @return The new cleaner
*/
public static Cleaner create(Object ob, Runnable thunk) {
return add(new Cleaner(ob, thunk));
}
强引用
代码中普遍存在的,类似 Object obj = new Object()这种
只要强引用还在,gc就不会清理这些对象