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

最新推荐文章于 2024-10-08 16:42:24 发布
最新推荐文章于 2024-10-08 16:42:24 发布
阅读量1w 收藏 23
点赞数 7
分类专栏： java 文章标签： java reference strong-ref soft-ref weak-ref
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rodbate/article/details/72857447
版权

前言

总所周知， 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 {

}

也可以画个简单的图理解一下：
这里写图片描述

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的源码。
这里写图片描述

现在是不是想到了软引用的一个使用场景，它相比与强引用可以避免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];
    }
}

运行 输出结果：

example.Sample@3f580216
example.Sample@3f580216
example.Sample@3f580216
example.Sample@3f580216
example.Sample@3f580216
example.Sample@3f580216
example.Sample@3f580216
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];
    }
}

运行 输出结果：

example.Sample@2a3c142c
example.Sample@2a3c142c
example.Sample@2a3c142c
example.Sample@2a3c142c
example.Sample@2a3c142c
example.Sample@2a3c142c
example.Sample@2a3c142c
--- 软引用对象被jvm回收了 ---- java.lang.ref.SoftReference@306d3b64
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];
    }
}

运行 输出结果：

example.Sample@234c0f50
example.Sample@234c0f50
--- 弱引用对象被jvm回收了 ---- java.lang.ref.WeakReference@16fea746
--- 回收对象 ---- 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.PhantomReference@40788638
false
--- 回收对象 ---- null
null
null
null
null
rodbate
关注
专栏目录
全面解析Java中的引用类型
09-02
本文将详细解析Java中的四种引用类型：强引用、软引用、弱引用和假象引用（幽灵引用）。 1. **强引用（Strong Reference）** - **定义**：强引用是最常见的引用类型，它代表了对象的常规引用。只要对象有强引用...
Java strong、soft、weak以及phantom引用
timorwu的博客
11-23 971
在JAVA中，JVM负责内存的分配与回收。这套机制使用方便却不够灵活，稍微不注意就容易造成OutOfMemoryError错误。 解决内存泄漏问题除了写代码谨慎之外，还可以配合不同的引用方式进行处理。从JDK1.2版本开始，把对象的引用分为四种级别，从而使程序能更加灵活的控制对象的生命周期。这四种级别由高到低依次为：强引用、软引用、弱引用和虚引用。一、强引用(strong)强引用是最普遍的一种
Java的四种引用类型
Fantasy
03-21 6664
Java有四种引用类型：强引用、软引用、弱引用、虚引用。 1. 强引用（StrongReference） 强引用是最常用的引用。如果一个对象具有强引用，那 GC（Gabage Collection，垃圾回收）绝不会回收它。 Object obj = new Object(); // 强引用 当内存空间不足，Java虚拟机宁愿抛出 OutOfMemoryError 错误，使程序异常终止，也...
Java进阶（JVM调优）——JVM调优参数 & JDK自带工具使用 & 内存溢出和死锁问题案例 & GC垃圾回收
weixin_45131680的博客
10-08 423
JVM作为Java进阶的知识，是需要Java程序员不断深度和理解的。本篇博客介绍JVM调优的相关知识，给出了一个demo案例，介绍了JVM调优的主要参数；介绍了jdk自带的jvm分析工具的使用；给出了一个内存溢出的调优场景，逐步分析定位问题，以及发生死锁的分析案例。Java进阶（1）——JVM的内存分配 & 反射Class类的类对象 & 创建对象的几种方式 & 类加载（何时进入内存JVM）& 注解 & 反射+注解的案例。
Java中Soft,Weak,Phantom应用的区别和使用
To Be the OnE
10-29 477
Java 1.2版本之后加入的这三个引用类型其实是对java中对象生命周期的一个增强，使得java对象的生命周期更加丰富。这三个引用类型主要在Java虚拟机的垃圾收集阶段发挥作用。 垃圾收集器对待软、弱和影子对象的方法不同，因为每一种都被设计用来为程序提供不同的服务。软引用使你可以创建内存中的缓存。它与程序的整体内存需求相关。弱引用使你可以创建规范映射，比如哈希表，它的关键字和值在没有其...
【Java中四种引用类型】
Java程序员廖志伟
07-17 1103
弱引用（Weak Reference）：是一种比软引用更弱的引用类型，它的生命周期只能存活到下一次垃圾收集之前，即只要被垃圾收集器扫描到，就会被回收。Java中的四种引用类型分别是强引用（Strong Reference）、软引用（Soft Reference）、弱引用（Weak Reference）和虚引用（Phantom Reference）。强引用（Strong Reference）：是使用最普遍的引用类型，它直接指向对象，并且只要存在强引用，垃圾收集器就不会回收该对象。
Java的4种引用类型
weixin_40482816的博客
08-23 2825
java为引用类型专门定义了一个类叫做。Reference是跟java垃圾回收机制息息相关的类，通过探讨Reference的实现可以更加深入的理解java的垃圾回收是怎么工作的。引用的结构图如下：引用队列是为了配合SoftReference、WeakReference、PhantomReference使用，它们三个在GC回收之前会被放到引用队列里ReferenceQueue保存下。
strong-soft-weak:各种Java参考的示例
05-02
本教程将深入探讨Java中的“强引用”（Strong Reference）、“软引用”（Soft Reference）、“弱引用”（Weak Reference）以及“幻影引用”（Phantom Reference）。这些引用类型在特定场景下能帮助开发者更精细地...
Java中的引用类型详解：强引用、软引用、弱引用与虚引用
最新发布
10-17
从JDK 1.2版本开始，Java引入了四种不同级别的引用：强引用（Strong Reference）、软引用（Soft Reference）、弱引用（Weak Reference）和虚引用（Phantom Reference）。这些引用类型提供了灵活的内存管理策略，允许...
Java引用类型编程开发技术共13页.pdf.zip
11-22
在Java中，有三种类型的数组：一维数组、二维数组和多维数组。数组提供了快速访问和操作数据的方式，但它们的大小在创建时必须固定。 4. 引用和对象：在Java中，变量可以是基本类型或引用类型。引用类型变量不直接...
Java中弱引用软引用虚引用及强引用的区别Java开发Ja
11-22
在Java编程语言中，引用类型是理解内存管理的关键概念之一。强引用、弱引用、软引用和虚引用是四种不同的引用强度，它们在垃圾回收机制中扮演着不同的角色。了解这些引用类型对于优化内存使用、防止内存泄漏以及合理...
Java中的四种引用类型
sugarxxc的博客
09-26 8080
java中的四种引用类型
Java数据类型：引用类型
epitomizelu的专栏
05-16 2673
引用类型，顾名思义，是用于存储对象引用（或称为句柄）的数据类型。引用类型不是类或者对象，只是变量的一种类型。当我们声明一个引用类型的变量时，该变量并不直接存储对象本身(如下图的变量obj1)，而是存储了指向对象在内存中位置的一个地址(如下图的堆地址1这意味着，通过引用类型的变量，能够间接地操作对象。通过引用类型的变量对Java对象进行操作，赋予Java对象以生命力。通过本文的解析与示例，希望读者能更加深入地掌握引用类型，灵活运用这一强大工具，构建更加高效、健壮的Java应用程序。
java中四种引用类型
2301_78021017的博客
05-14 822
弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它。程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。程序发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的。的内存空间，当用户再次需要浏览该雇员的档案信息的时候，重新构建该雇员的信息。一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。
java的四种引用类型
qq_19952029的博客
09-14 475
一、强引用 String s = "kkk"; s属于强引用，只要s属于根可达对象，则就算内存溢出，gc也不会回收 二、软应用 gc正常不会回收，除非内存不够用则会回收，多用于缓存机制场景；可单独开启线程监控引用队列，防止无效的软引用浪费内存； 可通过vm配置演示下面代码示例 -Xms4m -Xmx4m -XX:+PrintGC public class TestSoftReferance { private static final List<Object> TEST_
Java 四种引用类型
流华追梦的专栏
10-25 829
Java 引用是用于访问对象或变量的标识符。在 Java 中，引用是一种数据类型，它可以指向对象或变量的内存地址。Java 中的引用有四种类型：强引用（Strong Reference）、软引用（Soft Reference）、弱引用（Weak Reference）和虚引用（Phantom Reference）。强引用是最常用的引用类型，它指向一个对象，只要强引用存在，对象就不会被垃圾回收器回收。如果对象没有任何强引用指向它，垃圾回收器将在适当的时候回收该对象。
【Java】Java中的引用类型（全面解读）
double222222的博客
03-14 2635
在Java中，引用类型是指一种变量类型，它们用于引用对象而不是存储实际的数据值。当我们创建一个对象时，实际上在堆内存中分配了一块内存空间，并返回了一个指向该内存空间的引用。这个引用就是我们在代码中操作对象的句柄。在Java编程中，理解引用类型是编写高质量代码的关键。通过合理使用不同类型的引用，可以更好地管理内存，避免内存泄漏和内存溢出等问题。同时，对于不同类型引用的特性和用法有深入的了解，能够更好地设计出高效、健壮的程序。
Java中的4种引用类型，你知道几种？
wcwmsj的博客
01-16 1669
Java作为一门面向对象的编程语言，内存管理一直是程序员需要关注的重要方面。在Java中，垃圾回收机制负责自动管理内存，而引用类型则是垃圾回收的重要参考。本文将深入讨论Java中的四种引用类型：强引用、弱引用、软引用和虚引用，以及它们在内存管理中的应用和区别。
Java四种引用方式深度解析：强引用、软引用、弱引用、虚引用
本文详细解析了Java中的四种引用类型：强引用、软引用、弱引用和虚引用，帮助开发者更好地理解对象的生命周期以及如何配合垃圾回收机制。" 在Java中，内存管理主要是由垃圾回收（Garbage Collection，简称GC）自动...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值