Java 四大引用类型

GC 回收的优先级上: 强引用 -> 软引用 -> 弱引用 -> 虚引用

1.强引用

当内存不足，JVM开始进行 gc 时，对于强引用的对象不会进行回收，即使出现了OOM也不会回收。因此，强引用是造成内存泄露的主要原因。

class MyObject {
    @Override
    protected void finalize() throws Throwable{
        //finalize 通常目的是在某个对象内存被gc之前执行的操作
        System.out.println("------------invoke finalize method~~~");
    }
}
public class ReferenceDemo{
    public static void main(String[] args) throws InterruptedException{
        // 1. 强引用 --- 一定不会被 GC直至抛出OOM
        MyObject myObject = new MyObject();
        System.out.println("-----gc before\t" + myObject);
        System.gc();
        System.out.println("-----gc after\t " + myObject);
    }
}
// -----gc before	ThreadLocal.MyObject@6aaa5eb0
// -----gc after    ThreadLocal.MyObject@6aaa5eb0

2.软引用

当进行GC时，如果内存还足够，则不进行回收该对象，若内存不够，则回收该软引用对象内存空间

class MyObject {
    @Override
    protected void finalize() throws Throwable{
        //finalize 通常目的是在某个对象内存被gc之前执行的操作
        System.out.println("------------invoke finalize method~~~");
    }
}

public class ReferenceDemo{

    public static void main(String[] args) throws InterruptedException {
        //2. 软引用 --- 内存够用: 不会被GC  ||  内存不够用: 会被GC
        SoftReference<MyObject> reference = new SoftReference<>(new MyObject());
        // 通过 get() 方法返回真实对象
        System.out.println("-----gc before: "+reference .get());
        System.gc();
        Thread.sleep(100);
        System.out.println("-----gc after: " + reference .get());
    }
}
//-----gc before: ThreadLocal.MyObject@6aaa5eb0
//-----gc after: ThreadLocal.MyObject@6aaa5eb0

3. 弱引用

当 JVM 开始 gc 时，无论内存是否还足够，对于弱引用对象的内存空间都要进行回收

class MyObject {
    @Override
    protected void finalize() throws Throwable{
        //finalize 通常目的是在某个对象内存被gc之前执行的操作
        System.out.println("------------invoke finalize method~~~");
    }
}
public class ReferenceDemo{
    public static void main(String[] args) throws InterruptedException{
        //3. 弱引用 --- 只要JVM 一开始GC, 不管内存是否足够, 该内存区域都会被回收
        WeakReference<MyObject> weakReference = new WeakReference<>(new MyObject());
        System.out.println("内存够用,before gc: "+weakReference.get());
        System.gc();
        System.out.println("内存够用,after gc: "+weakReference.get());
    }
}
// 内存够用,before gc: ThreadLocal.MyObject@3498ed
// ------------invoke finalize method~~~
// 内存够用,after gc: null

4.虚引用

虚引用必须与 ReferenceQueue 一起使用，当 gc 准备回收一个对象，如果发现它还有虚引用，就会在回收之前，把这个虚引用加入到与之关联的 ReferenceQueue 中

class MyObject {
    @Override
    protected void finalize() throws Throwable{
        //finalize 通常目的是在某个对象内存被gc之前执行的操作
        System.out.println("------------invoke finalize method~~~");
    }
}
public class ReferenceDemo{
    public static void main(String[] args) throws InterruptedException{
        // 4. 虚引用: 必须要和引用队列一起使用, get()方法永远返回null
        PhantomReference<MyObject> reference = new PhantomReference<>(new                 MyObject(),new ReferenceQueue<>());
        //  无法返回引用对象
        System.out.println(reference .get());
        // 当被回收后, 该对象会进入引用队列 ReferenceQueue
        System.gc();
        Thread.sleep(200);
        if(reference .enqueue()){
            System.out.println("----------有虚对象被回收");
        }
    }
}
// null
// ------------invoke finalize method~~~
// ----------有虚对象被回收