Java中的四种引用类型 Strong, Soft, Weak And Phantom (一)

前言

总所周知， java不同于c/c++，它不需要程序员自已来管理内存(分配，释放内存)，java 会自己来管理内存，比如销毁某些不再被使用的对象。这些操作都是在一个后台线程默默进行(Garbage Collector Thread)，也就是垃圾收集器线程，根据jvm实现的策略来释放对象内存。但是程序编写者却无法控制这个后台线程，无法让它在你想要的时候开始释放内存，销毁对象，按照你的规定来销毁那些对象，释放内存，这些都是都jvm自己控制的。但是随着 java.lang.ref这个包下的类的引进，程序员拥有了一点点控制你创建的对象何时释放，销毁的权利，当然只是一点点。那接下来就来看看这些类和java中的四种引用类型有何对应关系。先来看看这四种引用类型，因为jvm在进行垃圾收集的时候，需要判断哪些对象需要销毁，这时就与这几种引用类型相关。

以下是这几种引用类型：

1. 强引用(Strong References)

强引用类型是我们平时写代码的时候最常用的引用，而大部分人往往都会忽略这个概念，都成一种理所当然的事情了。

接下来看看下面这个简单的例子：

public class Main {


    public static void main(String[] args) {

        //创建一个对象，new出来的对象都是分配在java堆中的
        Sample sample = new Sample();   //sample这个引用就是强引用

        sample = null;                  //将这个引用指向空指针,
                                        //那么上面那个刚new来的对象就没用任何其它有效的引用指向它了
                                        //也就说该对象对于垃圾收集器是符合条件的
                                        //因此在接下来某个时间点 GC进行收集动作的时候, 该对象将会被销毁，内存被释放

    }

}

class Sample {

}

也可以画个简单的图理解一下：

Java中的四种引用类型 Strong, Soft, Weak And Phantom (一)

2. 软引用(Soft References)

软引用在java.lang.ref包中有与之对应的类java.lang.ref.SoftReference。

重点：被弱引用指向的对象不会被垃圾收集器收集(即使该对象没有强引用指向它)，除非jvm使用内存不够了，才会对这类对象进行销毁，释放内存。举个简单的例子：

public class Main {

    public static void main(String[] args) {

        //创建一个对象，new出来的对象都是分配在java堆中的
        Sample sample = new Sample();   //sample这个引用就是强引用

        //创建一个软引用指向这个对象   那么此时就有两个引用指向Sample对象
        SoftReference<Sample> softRef = new SoftReference<Sample>(sample);

        //将强引用指向空指针 那么此时只有一个软引用指向Sample对象
        //注意：softRef这个引用也是强引用，它是指向SoftReference这个对象的
        //那么这个软引用在哪呢？ 可以跟一下java.lang.Reference的源码 
        //private T referent; 这个才是软引用， 只被jvm使用
        sample = null;

        //可以重新获得Sample对象，并用一个强引用指向它
        sample = softRef.get();
    }

}

class Sample {

}

有兴趣可以去看看Reference的源码。

Java中的四种引用类型 Strong, Soft, Weak And Phantom (一)

现在是不是想到了软引用的一个使用场景，它相比与强引用可以避免OOM。

现在可以简单的测试下当jvm内存不足的情况下，软引用的回收情况。

为了更快的看到结果，我限制了jvm的最大堆内存 -Xmx100m 为100m

public class Main {

    private static final List<Object> TEST_DATA = new LinkedList<>();


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

        //创建一个对象，new出来的对象都是分配在java堆中的
        Sample sample = new Sample();   //sample这个引用就是强引用

        //创建一个软引用指向这个对象   那么此时就有两个引用指向Sample对象
        SoftReference<Sample> softRef = new SoftReference<Sample>(sample);

        //将强引用指向空指针 那么此时只有一个软引用指向Sample对象
        //注意：softRef这个引用也是强引用，它是指向SoftReference这个对象的
        //那么这个软引用在哪呢？ 可以跟一下java.lang.Reference的源码
        //private T referent; 这个才是软引用， 只被jvm使用
        sample = null;

        //可以重新获得Sample对象，并用一个强引用指向它
        //sample = softRef.get();

        new Thread(){
            @Override
            public void run() {
                while (true) {
                    System.out.println(softRef.get());
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    TEST_DATA.add(new byte[1024 * 1024 * 5]);
                }
            }
        }.start();

        Thread.currentThread().join();
    }

}

class Sample {
    private final byte[] data;

    public Sample() {
        data = new byte[1024 * 1024 * 10];
    }
}

运行输出结果：

[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
null
null
Exception in thread "Thread-0" java.lang.OutOfMemoryError: Java heap space
	at example.Main$1.run(Main.java:42)

可以看到当jvm内存耗尽的时候，会将弱引用的对象进行回收上面的例子的10m，且刚好还可以分配两次 5m一次，输出了两次null也证明了这一点

当然我们在创建软引用时，还可以传入ReferenceQueue，这个队列有啥用呢？当jvm回收某个软引用对象之后会将该SoftReference对象(例子中的softRef对象)添加进这个队列，因此我们就知道这个对象啥时候被回收了，可以做一些我们想做的操作。

public SoftReference(T referent, ReferenceQueue<? super T> q) {
        super(referent, q);
        this.timestamp = clock;
}

Reference(T referent, ReferenceQueue<? super T> queue) {
        this.referent = referent;
        this.queue = (queue == null) ? ReferenceQueue.NULL : queue;
}

还是举个简单的例子

public class Main {

    private static final List<Object> TEST_DATA = new LinkedList<>();

    private static final ReferenceQueue<Sample> QUEUE = new ReferenceQueue<>();


    public static void main(String[] args) {

        //创建一个对象，new出来的对象都是分配在java堆中的
        Sample sample = new Sample();   //sample这个引用就是强引用

        //创建一个软引用指向这个对象   那么此时就有两个引用指向Sample对象
        SoftReference<Sample> softRef = new SoftReference<Sample>(sample, QUEUE);

        //将强引用指向空指针 那么此时只有一个软引用指向Sample对象
        //注意：softRef这个引用也是强引用，它是指向SoftReference这个对象的
        //那么这个软引用在哪呢？ 可以跟一下java.lang.Reference的源码
        //private T referent; 这个才是软引用， 只被jvm使用
        sample = null;

        //可以重新获得Sample对象，并用一个强引用指向它
        //sample = softRef.get();

        new Thread(){
            @Override
            public void run() {
                while (true) {
                    System.out.println(softRef.get());
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                        Thread.currentThread().interrupt();
                    }
                    TEST_DATA.add(new byte[1024 * 1024 * 5]);
                }
            }
        }.start();

        new Thread(){
            @Override
            public void run() {
                while (true) {
                    Reference<? extends Sample> poll = QUEUE.poll();
                    if (poll != null) {
                        System.out.println("--- 软引用对象被jvm回收了 ---- " + poll);
                        System.out.println("--- 回收对象 ---- " + poll.get());
                    }
                }
            }
        }.start();

        try {
            Thread.currentThread().join();
        } catch (InterruptedException e) {
            System.exit(1);
        }
    }

}

class Sample {
    private final byte[] data;

    public Sample() {
        data = new byte[1024 * 1024 * 10];
    }
}

运行输出结果：

[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
--- 软引用对象被jvm回收了 ---- [email protected]
null
--- 回收对象 ---- null
null
Exception in thread "Thread-0" java.lang.OutOfMemoryError: Java heap space
	at example.Main$1.run(Main.java:47)

3. 弱引用(Weak References)

弱引用会被jvm忽略，也就说在GC进行垃圾收集的时候，如果一个对象只有弱引用指向它，那么和没有引用指向它是一样的效果，jvm都会对它就行果断的销毁，释放内存。其实这个特性是很有用的，jdk也提供了java.util.WeakHashMap这么一个key为弱引用的Map。比如某个资源对象你要释放(比如 db connection), 但是如果被其它map作为key强引用了，就无法释放，被jvm收集。

来个简单的例子：

public class Main {

    private static final List<Object> TEST_DATA = new LinkedList<>();

    private static final ReferenceQueue<Sample> QUEUE = new ReferenceQueue<>();


    public static void main(String[] args) {

        //创建一个对象，new出来的对象都是分配在java堆中的
        Sample sample = new Sample();   //sample这个引用就是强引用

        //创建一个弱引用指向这个对象   那么此时就有两个引用指向Sample对象
        //SoftReference<Sample> softRef = new SoftReference<Sample>(sample, QUEUE);
        WeakReference<Sample> weakRef = new WeakReference<Sample>(sample, QUEUE);
        //将强引用指向空指针 那么此时只有一个弱引用指向Sample对象
        //注意：softRef这个引用也是强引用，它是指向SoftReference这个对象的
        //那么这个弱引用在哪呢？ 可以跟一下java.lang.Reference的源码
        //private T referent; 这个才是弱引用， 只被jvm使用
        sample = null;

        //可以重新获得Sample对象，并用一个强引用指向它
        //sample = softRef.get();

        new Thread(){
            @Override
            public void run() {
                while (true) {
                    System.out.println(weakRef.get());
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                        Thread.currentThread().interrupt();
                    }
                    TEST_DATA.add(new byte[1024 * 1024 * 5]);
                }
            }
        }.start();

        new Thread(){
            @Override
            public void run() {
                while (true) {
                    Reference<? extends Sample> poll = QUEUE.poll();
                    if (poll != null) {
                        System.out.println("--- 弱引用对象被jvm回收了 ---- " + poll);
                        System.out.println("--- 回收对象 ---- " + poll.get());
                    }
                }
            }
        }.start();

        try {
            Thread.currentThread().join();
        } catch (InterruptedException e) {
            System.exit(1);
        }
    }

}

class Sample {
    private final byte[] data;

    public Sample() {
        data = new byte[1024 * 1024 * 10];
    }
}

运行输出结果：

[email protected]
[email protected]
--- 弱引用对象被jvm回收了 ---- [email protected]
--- 回收对象 ---- null
null
null
null
null
null
null
null
Exception in thread "Thread-0" java.lang.OutOfMemoryError: Java heap space
	at example.Main$1.run(Main.java:47)

从结果中可以清晰的看到弱引用对象并不需要在jvm耗尽内存的情况下才进行回收，是可以随时回收的。

4. 虚幻引用(Phantom References)

虚幻应用和弱引用的回收机制差不多，都是可以被随时回收的。但是不同的地方是，它的构造方法必须强制传入ReferenceQueue，因为在jvm回收前(重点：对，就是回收前，软引用和弱引用都是回收后)，会将PhantomReference对象加入ReferenceQueue中; 还有一点就是PhantomReference.get()方法永远返回空，不管对象有没有被回收。

源码： java.lang.ref.PhantomReference
    /**
     * Returns this reference object's referent.  Because the referent of a
     * phantom reference is always inaccessible, this method always returns
     * <code>null</code>.
     *
     * @return  <code>null</code>
     */
    public T get() {
        return null;
    }

来个例子看看：

public class Main {

    private static final List<Object> TEST_DATA = new LinkedList<>();

    private static final ReferenceQueue<Sample> QUEUE = new ReferenceQueue<>();


    public static void main(String[] args) {

        Sample sample = new Sample();

        PhantomReference<Sample> phantomRef = new PhantomReference<>(sample, QUEUE);
        sample = null;

        new Thread(){
            @Override
            public void run() {
                while (true) {
                    System.out.println(phantomRef.get());
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                        Thread.currentThread().interrupt();
                    }
                    TEST_DATA.add(new byte[1024 * 1024 * 5]);
                }
            }
        }.start();

        new Thread(){
            @Override
            public void run() {
                while (true) {
                    Reference<? extends Sample> poll = QUEUE.poll();
                    if (poll != null) {
                        System.out.println("--- 虚幻引用对象被jvm回收了 ---- " + poll);
                        System.out.println(poll.isEnqueued());
                        System.out.println("--- 回收对象 ---- " + poll.get());
                    }
                }
            }
        }.start();

        try {
            Thread.currentThread().join();
        } catch (InterruptedException e) {
            System.exit(1);
        }
    }

}

class Sample {
    private final byte[] data;

    public Sample() {
        data = new byte[1024 * 1024 * 10];
    }
}

运行结果：

null
null
--- 虚幻引用对象被jvm回收了 ---- java.lang.ref.Phantom[email protected]
false
--- 回收对象 ---- null
null
null
null
null

Java中的四种引用类型 Strong, Soft, Weak And Phantom (一)

1. 强引用(Strong References)

2. 软引用(Soft References)

3. 弱引用(Weak References)

4. 虚幻引用(Phantom References)

继续阅读

关于Gradle配置的小结

Java小案例——随机数猜测随机数猜测

nginx location中斜线的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的简单使用

neo4j之cypher使用文档

GitHub连夜封杀！这份阿里 10W 字内部 Java 字面试手册到底有多强？

spark/scala关于【资源文件】加载方法概述外部文件加载方案测试资源文件打包入jar包中小结

mybatis_入门程序Mybatis入门

AOP编程_Android优雅权限框架(1)概念基础，2021金三银四前言正文大纲正文

Effective Java 8:通用程序设计

OOM三种类型

工厂模式-三种类型

【递归】高效率求2的n次幂

win10本地scala和spark安装安装scala安装spark

scala (3) Function 和 Method