JAVA中类型引用分为：强引用、软引用、弱引用、虚引用

强引用

强引用，GC默认不回收，只有在对象没有被引用的时候进行GC回收

/**
 * @Description: 强引用：对象没有引用GC开始回收
 * @Author haodd
 * @Date 2022/5/19 11:08
 * @Version 1.0
 */
public class StrongRef {

    public static void main(String[] args) throws InterruptedException {

        StrongRef m = new StrongRef();

        System.out.println(m);

        System.gc();

        System.out.println(m);

        m = null;

        System.gc();

        /** 此处等待，防止GC线程没有执行完 */
        Thread.sleep(100);

        System.out.println(m);

    }

    @Override
    protected void finalize() throws Throwable {
        System.out.println("GC垃圾回收");
        super.finalize();
    }
}

软引用

软引用，GC默认不回收，在堆内存不够的时候，GC回收软应用
此处进行实验需要设置JVM最大堆内存，-Xmx20M

import java.lang.ref.SoftReference;

/**
 * @Description: 软引用：默认GC不回收，如果堆内存满了，软引用被GC回收
 * @Author haodd
 * @Date 2022/5/19 11:14
 * @Version 1.0
 */
public class SoftRef {

    //TODO 实验环境的时候需要设置JVM最大堆内存：-Xmx20M
    public static void main(String[] args) throws InterruptedException {

        SoftReference<byte[]> m = new SoftReference<>(new byte[1024 * 1024 * 10]);

        System.out.println(m.get());

        System.gc();

        Thread.sleep(800);

        System.out.println(m.get());

        byte[] bytes = new byte[1024 * 1024 * 11];

        System.out.println(m.get());

    }

}

软引用

弱引用，遇到GC就回收

import java.lang.ref.WeakReference;

/**
 * @Description: 弱引用，遇到GC就会被回收
 * @Author haodd
 * @Date 2022/5/19 14:02
 * @Version 1.0
 */
public class WeakRef {

    public static void main(String[] args) throws InterruptedException {

        WeakReference<WeakRef> m = new WeakReference<>(new WeakRef());

        System.out.println(m.get());

        System.gc();

        Thread.sleep(500);

        System.out.println(m.get());

    }

    /** GC垃圾回收的会后会调用此方法，但不一定每次都会调用 */
    @Override
    protected void finalize() throws Throwable {
        System.out.println("GC垃圾回收");
        super.finalize();
    }
}

虚引用

虚引用，创建虚引用的时候，需要传入对象和queue，当虚引用的对象被回收后，会在queue中添加被回收的记录
虚引用可以用来管理堆外内存，正常网络通信下，数据先到电脑内存，最后才能到JVM内存，经过两次拷贝，效率低
所以JVM提供了直接内存管理，因为此处直接操作的是操作系统内存，所以JVM没办法管理堆外内存，因此在会在被回收的时候才会给queue中发送一条消息，告诉你该清理堆外内存了

import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;
import java.util.concurrent.TimeUnit;

/**
 * @Description: 虚引用，创建虚引用的时候，需要传入对象和queue，当虚引用的对象被回收后，会在queue中添加被回收的记录
 *               虚引用可以用来管理堆外内存，正常网络通信下，数据先到电脑内存，最后才能到JVM内存，经过两次拷贝，效率低
 *               所以JVM提供了直接内存管理，因为此处直接操作的是操作系统内存，
 *               所以JVM没办法管理堆外内存，因此在会在被回收的时候才会给queue中发送一条消息，告诉你该清理堆外内存了
 * @Author haodd
 * @Date 2022/5/19 17:57
 * @Version 1.0
 */
public class PhantomRef {

    public static void main(String[] args) throws InterruptedException {

        Object obj = new Object();
        ReferenceQueue<Object> QUEUE = new ReferenceQueue<>();
        PhantomReference<Object> reference = new PhantomReference<>(obj,QUEUE);

        obj = null;
        System.out.println(reference.get());

        System.gc();
        TimeUnit.SECONDS.sleep(6);

        System.out.println(reference.get());
        System.out.println(QUEUE.poll());

    }

}