引用关系四大引用

堆（包括里面的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就不会清理这些对象

四大引用