Java 对象各种引用类型作用（强引用、软引用、弱引用、虚引用）

在java中我们用的最多的是new，但这属于强引用类型，强引用是造成 Java 内存泄漏的主要原因之
一，在内存不足时，一定需要牺牲某些对象，我们需要使用其它的引用类型，比如软引用

一图看懂所有引用类型：

相关代码

import java.util.Date;

/**
 * 强引用，JVM停止运行时终止
 * 
 * @author 游四七
 * @date 2019/9/28
 */
public class StrongReference {

	public static void main(String[] args) {
        User user = new User(1,"yousiqi");
        System.gc();
	}

}

import java.lang.ref.SoftReference;

/**
 * 软引用：用来引用还存在但非必须的对象。
 * 对于软引用对象，在 OOM 前，虚拟机会把这些对象列入回收范围中进行第二次回收，如果这次回收后，内存还是不够用，就 OOM。
 * 实现类：`SoftReference`。
 * <p>
 * -Xmx10m
 *
 * @author 游四七
 * @date 2019/12/22
 */
public class SoftRef {

    public static void main(String[] args) {

        User u = new User(1, "geym");
        SoftReference<User> userSoftRef = new SoftReference<User>(u);
        u = null;

        System.out.println(userSoftRef.get());
        System.gc();
        System.out.println("After GC:");
        System.out.println(userSoftRef.get());

        byte[] b = new byte[1024 * 925 * 7];
        System.gc();
        System.out.println(userSoftRef.get());
    }



}

import java.lang.ref.WeakReference;

/**
 * 弱引用：被弱引用引用的对象只能生存到下一次垃圾收集前，一旦发生垃圾收集，被弱引用所引用的对象就会被清掉。实现类：`WeakReference`。
 * 不管当前内存空间足够与否，都会回收它的内存
 *
 * @author 游四七
 * @date 2019/12/22
 */
public class WeakRef {

    public static void main(String[] args) {

        User u = new User(1, "yousiqi");
        WeakReference<User> userWeakRef = new WeakReference<User>(u);
        u = null;
        System.out.println(userWeakRef.get());
        System.gc();

        //不管当前内存空间足够与否，都会回收它的内存
        System.out.println("After GC:");
        System.out.println(userWeakRef.get());
    }


}

import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;


/**
 * 虚引用：对对象没有半毛钱影响，甚至不能用来取得一个对象的实例。
 * 它唯一的用途就是：当被一个虚引用引用的对象被回收时，系统会收到这个对象被回收了的通知。
 * 实现类：`PhantomReference`。
 * <p>
 * 不管当前内存空间足够与否，都会回收它的内存
 *
 * @author 游四七
 * @date 2019/12/22
 */
public class PhantomRef {

    static ReferenceQueue<User> phantomQueue = null;

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

        Thread t = new CheckRefQueue();
        t.setDaemon(true);
        t.start();

        User u = new User(1, "yousiqi");
        phantomQueue = new ReferenceQueue<User>();
        UserPhantomReference userPhantomRef = new UserPhantomReference(u, phantomQueue);
        u = null;
        //always  null
        System.out.println(userPhantomRef.get());
        System.gc();
        //不管当前内存空间足够与否，都会回收它的内存
        System.out.println("After GC:");
        System.out.println(userPhantomRef.get());

        Thread.sleep(1000);
    }


    /**
     * 检查引用队列（监听对象是否回收）
     *
     * @author 游四七
     * @date 2019/12/22
     */
    public static class CheckRefQueue extends Thread {

        @Override
        public void run() {
            while (true) {
                if (phantomQueue != null) {
                    UserPhantomReference obj = null;
                    try {
                        obj = (UserPhantomReference) phantomQueue.remove();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    if (obj != null) {
                        System.out.println("user id " + obj.uid + " is delete");
                    }

                }
            }
        }
    }

    public static class UserPhantomReference extends PhantomReference<User> {
        int uid;

        public UserPhantomReference(User referent, ReferenceQueue<? super User> q) {
            super(referent, q);
            uid = referent.id;
        }
    }

}

/**
 * 用户对象
 *
 * @author 游四七
 * @date 2019/12/22
 */
public class User {

    public int id;

    public String name;

    public User(int id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    protected void finalize() throws Throwable {
        super.finalize();
        System.out.println("[id=" + String.valueOf(id) + ",name=" + name + "] is gc");
    }

    @Override
    public String toString() {
        return "[id=" + String.valueOf(id) + ",name=" + name + "]";
    }
}

总结：

其实深入了解后发现引用并没有那么难，只不过我们平时没有场景能用到，比如大内存对象就可以用软引用方式，内存不够用直接回收它

参考：

深入理解 Java 虚拟机 第2版