Java的四大引用之强软弱虚

最新推荐文章于 2024-03-26 18:57:00 发布

闲着无聊整些资料

最新推荐文章于 2024-03-26 18:57:00 发布

阅读量340

点赞数 1

分类专栏： JVM 文章标签： java

本文链接：https://blog.csdn.net/qq_43418737/article/details/125348725

版权

JVM 专栏收录该内容

6 篇文章 1 订阅

订阅专栏

Java从1.2版本开始引入了4种引用，这4种引用分别是强引用、软引用、弱引用、虚引用，根据他们的引用级别依次为 强引用 > 软引用 > 弱引用 > 虚引用。

下面我就用几个例子分别说说他们几个的实现方式及其特点。

一、测试前的准备

1.1、建造测试对象

首先在测试之前，我们先创建一个对象，去继承Object类，重写finalize方法，以便后续更加清楚明了的查看gc回收的情况，代码如下：

public class Reference extends Object {
    /**
     * 创建一个大的属性去占用内存
     */
    private byte[] jvmMemory = new byte[1024 * 1024];
    @Override
    protected void finalize() throws Throwable {
        /**
         * 重写finalize方法的目的是在gc的时候能打印下面这句话让我们知道对象什么时候被回收了
         */
        super.finalize();
        System.out.println("对象=" + this + "被gc回收");
    }
}

1.2、测试对象大小设置jvm参数

其次我们可以借助工具openjdk测试一下这个对象的大小，以便于我们设置jvm的参数，控制jvm抛出oom，相关测试如下：

<dependency>
  <groupId>org.openjdk.jol</groupId>
  <artifactId>jol-core</artifactId>
  <version>0.14</version>
</dependency>

package com.sxx.controller;

import com.sxx.bean.Reference;
import org.openjdk.jol.info.GraphLayout;

public class ObjectTest {
    public static void main(String[] args) {
        Reference reference = new Reference();
        GraphLayout graphLayout = GraphLayout.parseInstance(reference);
        //打印reference对象的在内存中占用的地址
        System.out.println(graphLayout.toPrintable());
        //打印reference的所有内存大小
        System.out.println(graphLayout.toFootprint());
    }
}

测试的结果如下：

二、测试

2.1、强引用

强引用就是程序中一般使用的引用类型，即我们直接new出来的对象。强引用的对象是可触及的，不会被回收，只要强引用关系存在，jvm宁肯抛出OutOfMemoryError也不会对具有与强引用的对象做回收。

具体可参考如下代码：

import com.sxx.bean.Reference;

/**
 * 强引用测试
 */
public class StrongReferenceTest {
    public static void main(String[] args) {
        Reference r1 = new Reference();
        System.out.println("r1=" + r1);
        Reference r2 = new Reference();
        System.out.println("r2=" + r2);
        try {
            Reference r3 = new Reference();
            System.out.println("r3=" + r3);
            Reference r4 = new Reference();
            System.out.println("r4=" + r4);
        }catch (Error e){
            e.printStackTrace();
        }
        System.out.println("=======================");
        System.out.println("r1=" + r1);
        System.out.println("r2=" + r2);
    }
}

打印结果如下：

从上面结果可以看出，只要强引用关系存在，jvm宁肯抛出OutOfMemoryError也不会对具有与强引用的对象做回收。

2.2、软引用

软引用主要是用来描述一些还有用但非必须的对象。被软引用关联的对象，只有在系统发生内存溢出之前对其进行垃圾回收，如果本次垃圾回收仍然没有回收到足够的内存才会抛出内存溢出异常。

import com.sxx.bean.Reference;
import java.lang.ref.SoftReference;

/**
 * 软引用
 */
public class SoftReferenceTest {
    public static void main(String[] args) {
        SoftReference<Reference> s1 = new SoftReference<>(new Reference());
        System.out.println("s1=" + s1.get());
        SoftReference<Reference> s2 = new SoftReference<>(new Reference());
        System.out.println("s2" + s2.get());
        System.out.println("内存不足，开始触发垃圾回收");
        try{
            Reference reference3 = new Reference();
            System.out.println("reference3=" + reference3);
            Reference reference4 = new Reference();
            System.out.println("reference4=" + reference4);
        }catch (Error e){
            e.printStackTrace();
        }
        System.out.println("垃圾回收结束");
        System.out.println("s1=" + s1.get());
        System.out.println("s2=" + s2.get());
    }
}

打印结果如下:

从上面可以看出，在第20行准备创建reference4时内存不足，触发了一次gc对s1、s2进行回收，但是回收之后的内存仍然不够创建reference4，因此抛出OOM。

2.3、弱引用

弱引用也是用来描述那些非必须对象，但是它的强度比软引用更弱一些，被弱引用关联的对象只能存活到下一次垃圾收集发生为止，也就是说当垃圾收集器开始工作，无论当前内存是否足够，都会回收掉只被弱引用关联的对象。

import com.sxx.bean.Reference;
import java.lang.ref.WeakReference;

/**
 * 弱引用
 */
public class WeakReferenceTest {
    public static void main(String[] args) {
        WeakReference<Reference> w1 = new WeakReference<>(new Reference());
        System.out.println("w1=" + w1.get());
        WeakReference<Reference> w2 = new WeakReference<>(new Reference());
        System.out.println("w2=" + w2.get());
        System.out.println("开始进行垃圾回收");
        System.out.println("=======================");
        System.gc();
        System.out.println("垃圾回收结束");
        System.out.println("=======================");
        System.out.println("w1=" + w1.get());
        System.out.println("w2=" + w2.get());
    }
}

打印结果如下：

从上面打印结果可以看出，不管内存是否足够，当gc被触发时，不管内存是否充足，弱引用对象都会被回收。

2.4、虚引用

虚引用顾名思义，就是形同虚设，是最弱的一种引用关系。与其他几种引用都不同，虚引用并不会决定对象的生命周期，也无法通过虚引用来取得一个对象实例。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收，它的唯一作用就是在这个对象被收集器回收时收到一个系统通知。

import com.sxx.bean.Reference;
import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;

/**
 * 虚引用
 */
public class VirtualReferenceTest {
    public static void main(String[] args) {
        WeakReference<Reference> w1 = new WeakReference<>(new Reference());
        System.out.println("w1=" + w1.get());
        ReferenceQueue queue = new ReferenceQueue();
        PhantomReference<Reference> p1 = new PhantomReference<Reference>(w1.get(), queue);
        System.out.println("p1=" + p1.get());
        System.out.println("开始触发垃圾回收");
        System.gc();
        System.out.println("发垃圾回收结束");
        System.out.println("p1=" + p1.get());
    }
}

打印结果如下：