结合代码理解java的四种引用类型

晓之木初

已于 2023-04-18 10:14:30 修改

阅读量1k

点赞数 2

分类专栏： # 《深入理解Java 虚拟机》文章标签： java

于 2021-07-08 00:26:08 首次发布

本文链接：https://blog.csdn.net/u014454538/article/details/118163695

版权

《深入理解Java 虚拟机》专栏收录该内容

9 篇文章 0 订阅

订阅专栏

1. 絮絮叨叨

在工作中使用到了ThreadLocal，在学习ThreadLocal的过程中，自己发现Java的引用类型是一个基础知识
而自己对Java的四种引用类型忘得差不多了，只知道一些概念，具体每种类型的特点一点都不知道 😂
于是，抽空复习了一下Java的四种引用类型，其实是学习 😂
附上当年的博客：Java的四种引用类型、内存分配策略、回收策略(Full GC的触发条件）、内存泄露
本文将结合代码的方式，去理解、验证每种引用类型。

1.1 Java基本数据类型和引用类型的内存结构

说到JVM，肯定少不了内存结构、垃圾回收机制等
给个自己之前博客的链接：Java内存结构、垃圾回收机制
里面有这样的一些描述：
（1）Java虚拟机栈存储了局部变量表、操作数栈、动态链接、方法出口等信息
（2）几乎所有的实例对象和数组都在堆上分配内存，堆是Java垃圾回收的主要区域
这次，也看到了一个很不错的博文，里面讲解了Java的基本数据类型和引用类型在JVM内存的存放方式

基本数据类型

Java的基本数据类型的值，存放在虚拟机栈中；
对Java基本数据类型声明并赋值，会分配一个新的虚拟机栈内存
修改基本数据类型的值，是直接对内存中的值做修改，而内存地址不变

引用类型

数组和实例对象都是Java的引用类型，值存放在堆内存，而虚拟机栈中存储该内存的地址，即存储一个指向该内存的引用
引用类型的赋值，实际是引用的拷贝
指向同一内存地址的两个引用，一个引用修改堆内存中的值，另一个引用会被无辜牵连
==对基本数类型来说，是判断值是否相等；对引用类型来说，是判断其是否指向相同的堆内存地址

2. Java的四种引用类型

在JDK 1.2以前，对引用的定义十分简单：

如果reference类型的数据中存储的数值代表的是另外一块内存的起始地址，就成这块内存代表着一个引用
也就是说，引用其实是一个指向对象内存地址的指针，对象只有被引用或未被引用两种情况
这样的话，只有当对象不存在任何引用时，才能被垃圾回收
这种设计使得垃圾回收十分死板：一些不重要的、存在引用的对象其实是可以回收，例如缓存的图片
JDK 1.2开始，Java对引用的概念进行了扩展，设计了四种引用类型：强引用（Strong Reference）、软引用（Soft Reference）、弱引用（Weak Reference）、虚引用（Phantom Reference）

2.1 强引用

2.1.1 概述

常见的，new一个对象或数组就是一个强引用：stu是指向新建对象的强引用
```
Student stu = new Student("张三", 21);
```

强引用具有以下特点：

当JVM内存不足时，即使抛出OOM，也不会回收被强引用关联的对象
被强引用关联的对象，可以直接通过引用进行访问
通过将强引用置为null，可以断开强引用和对象之间的关联
```
stu = null；
```
类似Student temp = stu;这样的对象赋值操作，其实是强引用的拷贝

2.1.2 代码示例

代码一

被强引用关联的对象可以直接获取，且不会被gc回收

public static void test1() throws InterruptedException {
    // student是强引用，new Student()是强引用关联的对象
    // 强引用关联的对象，在内存不足时，不会被gc
    Student student = new Student("lucy", 24);
    List<byte[]> buffers = new ArrayList<>();

    // 强引用关联的对象可直接获取
    System.out.println("Student: " + student.getName() + ", age: " + student.getAge());

    // 线程不断为buffers分配新的内存，模拟内存溢出
    // 观察强引用关联的对象是否被回收
    CountDownLatch countDownLatch = new CountDownLatch(1);
    new Thread(() -> {
        countDownLatch.countDown();
        while (true) {
            try {
                buffers.add(new byte[1024 * 1024]);
            } catch (OutOfMemoryError error) {
                // 即使内存溢出，student对象依然存在
                if (student != null) {
                    System.out.println("student对象未被垃圾回收");
                }
                throw error;
            }
        }
    }).start();
    countDownLatch.await();
}

运行结果：

代码二：

强引用的拷贝以及断开关联

public static void test2() {
    // 将强引用置为null，表示取消与被关联对象之间的引用
    // 如果被关联对象不存在其他引用，则在gc时会被回收
    StudentOverride student = new StudentOverride("lucy", 24);

    // 第一次gc，对象存在强引用，不会被回收
    System.gc();
    if (student != null) {
        System.out.println("对象" + student + "未被回收");
    }

    // 第二次gc，由于存在赋值产生的新引用，对象不会被回收
    StudentOverride temp = student;
    if (temp == student) {
        System.out.println("temp和student指向同一对象");
    }
    student = null;
    System.gc();
    if (temp != null) {
        System.out.println("对象" + temp + "未被回收");
    }

    // 第三次gc，对象不存在任何引用，会被回收
    temp = null;
    System.gc();
}

运行结果：

其中，Student类的定义如下：

public class Student {
    private String name;
    private int age;
}

StudentOverride类在Student类的基础上，重写了finalize()方法

@Override
protected void finalize() throws Throwable {
    try {
        super.finalize();
    } catch (Throwable throwable) {
        System.out.println("对象" + this + "回收失败");
        throw  throwable;
    }

    System.out.println("对象" + this + "被成功回收");
}

2.2 软引用

2.2.1 概述

软引用关联的对象，其生命力比强引用稍弱一点，在内存不足时会被回收。
需要通过SoftReference创建对象的软引用

软引具有以下特点：

被软引用关联的对象不能直接使用，需要通过get()方法获取
只被软引用关联的对象，在内存充足时不会被回收；内存不足，则会被回收
软引用适用于对内存敏感的高速缓存，例如图片缓存框架中的图片缓存可以使用软引用
软引用可以与关联一个引用队列，如果能从引用队列中poll出软引用，说明软引用关联的对象已被回收

引用队列：管理需要被清理的软引用

当软引用关联的对象被回收后，作为一个对象的软引用也应该在适当的时候被清理，以避免大量软引用带来的内存泄漏
通过关联引用队列，不仅可以监听软引用关联的对象是否已被回收，还可以改变软引用的生命周期

2.2.2 代码示例

代码一

被软引用关联的对象，在内存不足时会被回收

public void test1() throws InterruptedException {
    StudentOverride student = new StudentOverride("lucy", 25);
    // 创建对象的软引用
    SoftReference<StudentOverride> softReference = new SoftReference<>(student);
    // 断开对象的强引用
    student = null;

    // 内存充足，gc时软引用关联的对象不会被回收
    System.gc();
    // 通过get获取软引用关联的对象
    if (softReference.get() != null) {
        System.out.println("对象" + softReference.get() + "未被回收");
    }

    // 内存不足，gc时软引用关联的对象被回收
    CountDownLatch countDownLatch = new CountDownLatch(1);
    List<byte[]> buffers = new ArrayList<>();
    new Thread(() -> {
        countDownLatch.countDown();
        while (true) {
            try {
                buffers.add(new byte[1024 * 1024]);
            } catch (OutOfMemoryError error) {
                System.out.println("内存不足，" + error.toString());
                if (softReference.get() == null) {
                    System.out.println("软引用指向的对象已被回收");
                }
                break;
            }
        }
    }).start();

    countDownLatch.await();
}

执行结果截图：

代码二

软引用与引用队列结合

public void test2() throws InterruptedException {
    StudentOverride student = new StudentOverride("lucy", 25);

    // 创建带引用队列的软引用
    ReferenceQueue<StudentOverride> queue = new ReferenceQueue<>();
    SoftReference<StudentOverride> softReference = new SoftReference<>(student, queue);
    // 断开对象的强引用
    student = null;

    // 内存充足，软引用软件的对象不会被回收
    // 引用队列中的暂无软引用
    System.gc();
    if (softReference.get() != null && queue.poll() == null) {
        System.out.println("对象" + softReference.get() + "未被回收，其软引用" + softReference + "尚未进入引用队列");
    }

    // 内存不足，gc时软引用关联的对象被回收
    CountDownLatch countDownLatch = new CountDownLatch(2);
    List<byte[]> buffers = new ArrayList<>();
    new Thread(() -> {
        countDownLatch.countDown();
        while (true) {
            try {
                buffers.add(new byte[1024 * 1024]);
            } catch (OutOfMemoryError error) {
                System.out.println("内存不足，" + error.toString());
                break;
            }
        }
    }).start();

    // 用于不断查询引用队列，以观察软引用关联的对象被回收，软引用会被放入引用队列
    new Thread(() -> {
        countDownLatch.countDown();
        SoftReference<StudentOverride> reference;
        while ((reference = (SoftReference<StudentOverride>) queue.poll()) == null) {
        }

        // 检查软引用关联的对象已经被回收，且软引用被加入引用队列
        if (softReference.get() == null && reference != null) {
            System.out.println("软引用关联的对象被回收，软引用" + reference + "已被加入引用队列");
            // 判断队列中的软引用是否和原本的一致
            if (softReference == reference) {
                System.out.println("进入引用队列的是软引用，而非软引用关联的对象");
            } else {
                System.out.println("进入引用队列的是软引用关联的对象");
            }
        }
    }).start();
    countDownLatch.await();
}

执行结果截图：

2.3 弱引用

2.3.1 概述

弱引用关联的对象，其生命力比软引用关联的对象更弱，无论内存是否充足，都会被回收
弱引用需要使用WeakReference进行创建

弱引用具有以下特点：

被弱引用关联的对象不能直接访问，可以通过get()获取
只被被弱引用关联的对象，无论内存是否充足，都会被回收
弱引用同样适用于对内存敏感的缓存
弱引用也可以关联引用队列，实现对弱引用的管理和被弱引用关联对象的监听

Thread中，存储<ThraeadLocal, value>的entry中，对ThraeadLocal的引用就是弱引用

2.3.2 代码示例

代码一：

无论内存是否充足，只被弱引用关联的对象都会被回收

public static void test1() {
    // 弱引用关联的对象，在垃圾回收时一定会被回收
    StudentOverride student = new StudentOverride("lucy", 21);
    WeakReference<StudentOverride> weakReference = new WeakReference<>(student);
    student = null;

    // 弱引用关联的对象尚未被回收
    if (weakReference.get() != null) {
        System.out.println("弱引用关联的对象" + weakReference.get() + "未被回收");
    }

    // gc后弱引用关联的对象被回收
    System.gc();
    if (weakReference.get() == null) {
        System.out.println("弱引用关联的对象被回收");
    }
}

执行结果截图：

代码

弱引用关联引用队列，使用isEnqueued()判断弱引用关联的对象是否被回收

public static void test3() throws InterruptedException {
    // 创建弱引用时指定了引用队列，当关联的对象被回收时，isEnqueued()为true，且被加入引用队列
    // 弱引用关联的对象，在垃圾回收时一定会被回收
    StudentOverride student = new StudentOverride("lucy", 21);
    ReferenceQueue<StudentOverride> queue = new ReferenceQueue<>();
    WeakReference<StudentOverride> weakReference = new WeakReference<>(student, queue);
    student = null;

    // 弱引用关联的对象尚未被回收，则isEnQueued()返回false，表明未被标记成回收对象
    if (weakReference.get() != null) {
        System.out.print("弱引用关联的对象" + weakReference.get() + "未被回收, isEnqueued(): " + weakReference.isEnqueued() + ",\\n");
        if (queue.poll() == null) {
            System.out.println("\n弱引用" + weakReference + "未被加入引用队列");
        }
    }

    // 内存不足，gc时弱引用关联的对象被回收
    System.gc();
    // 休息一段时间，等待弱引用被加入引用队列
    Thread.sleep(3000);
    if (weakReference.get() == null) {
        System.out.print("弱引用关联的对象被回收, isEnqueued(): " + weakReference.isEnqueued() + ", ");
        if (queue.poll() == weakReference) {
            System.out.println("弱引用" + weakReference + "被加入引用队列中");
        }
    }
}

执行结果截图

2.4 虚引用

2.4.1 概述

虚引用，又叫幻影引用，因为它对被关联对象的生命周期没有任何影响，
可以使用PhantomReference创建虚引用

虚引用具有以下特点：

被虚引用关联的对象，任何时候都可能被垃圾回收，容易发送内存泄漏（疑问：回收时间的不确定性？）
虚引用就像幽灵，不影响被关联对象的生命周期，也无法通过虚引用get()到被关联的对象
虚引用必须和引用队列一起使用，可以监听对象是否被回收，从而进行相应的处理。

虚引用，可以跟踪垃圾回收器对对象的收集活动
在Java的NIO中，使用虚引用管理堆外内存

2.4.2 代码示例

代码一

虚引用关联引用队列，

public static void main(String[] args) throws InterruptedException {
    // 虚引用必须与引用队列一起使用
    ReferenceQueue<StudentOverride> queue = new ReferenceQueue<>();
    PhantomReference<StudentOverride> phantomReference = new PhantomReference<>(new StudentOverride("john", 22), queue);

    // 虚引用就像幽灵一样，不影响被关联对象的生命周期，被关联对象可以在任意时刻被gc
    // 虚引用无法通过get()方法获取被关联对象
    if (phantomReference.get() == null) {
        System.out.println("虚引用" + phantomReference + "无法通过get()方法获取被关联对象");
    }

    // 模拟内存不足使得虚引用关联的对象被gc
    CountDownLatch countDownLatch = new CountDownLatch(2);
    List<byte[]> buffers = new ArrayList<>();
    new Thread(() -> {
        countDownLatch.countDown();
        while (true) {
            try {
                buffers.add(new byte[1024 * 1024]);
            } catch (OutOfMemoryError error) {
                System.out.println("内存溢出： " + error.toString());
                break;
            }
        }
    }).start();

    // 观察虚引用关联的对象被回收，虚引用是否被添加到引用队列中
    new Thread(() -> {
        countDownLatch.countDown();
        PhantomReference<StudentOverride> temp;
        while (true) {
            if ((temp = (PhantomReference<StudentOverride>) queue.poll()) != null && temp == phantomReference) {
                System.out.println("虚引用关联的对象被回收，虚引用" + phantomReference + "被放入引用队列中");
                // 可以在关联的对象被销毁时，做一些额外的事情
                // do something
                break;
            }
        }
    }).start();

    countDownLatch.await();
}

执行结果截图：

2.4.3 真实的应用场景：FileCleaningTracker

org.apache.commons.io.FileCleaningTracker类的实现就是利用了虚引用

继承虚引用的Tracker类

内部静态类Tracker继承了虚引用，必须关联一个引用队列
构造函数创建Tracker对象时：
- 将marker作为虚引用关联的对象，同时为该虚引用注册一个引用队列
- 同时，将文件路径存入Tracker中，为后续删除文件做准备
一旦marker被回收，虚引用会被加入到引用队列，从而可以从引用队列中获取（remove）一个虚引用

获取到虚引用，则删除Tracker中对应路径的文件，从而实现文件的清理

private static final class Tracker extends PhantomReference {
    private final String path;
    private final FileDeleteStrategy deleteStrategy;
    
    Tracker(String path, FileDeleteStrategy deleteStrategy, Object marker, ReferenceQueue queue) {
        super(marker, queue);  // 使用虚引用，marker回收后，tracker会被加入引用队列
        this.path = path;
        this.deleteStrategy = deleteStrategy == null ? FileDeleteStrategy.NORMAL : deleteStrategy;
    }
    // 发现marker已被回收，则删除对应的文件
    public boolean delete() { 
        return this.deleteStrategy.deleteQuietly(new File(this.path));
    }
}

从引用队列获取tracker是通过继承Thread的Reaper类线程实现，其run()方法不停尝试从引用队列中获取tracker

一旦获取到tracker，则删除文件、释放引用

public void run() {
    while(!FileCleaningTracker.this.exitWhenFinished || FileCleaningTracker.this.trackers.size() > 0) {
        FileCleaningTracker.Tracker tracker = null;

        try {
            tracker = (FileCleaningTracker.Tracker)FileCleaningTracker.this.q.remove();
        } catch (Exception var3) {
            continue;
        }

        if (tracker != null) {
            tracker.delete();
            tracker.clear();
            FileCleaningTracker.this.trackers.remove(tracker);
        }
    }

}

Tracker的实质：实现了文件与marker的绑定，由于marker使用了虚引用，marker被回收可以通过引用队列检测到，从而可以删除与marker绑定的文件

3. 总结

jvm内存的虚拟机栈与堆：

局部变量表、操作数栈、方法出口、动态链接等存放在jvm栈
几乎所有的实例对象和数组存放在堆中
对引用数据类型，堆中存放示例对象、栈中存放指向该对象的引用

java的四种引用类型

通过new创建实例化对象或数组，是强引用；被强引用关联的对象，无法被垃圾回收，需要主动断开连接，避免内存泄漏
通过SoftReference创建软引用，被软引用关联的对象在内存不足时，会被垃圾回收；可以通过get()获取被关联对象，与引用队列一起使用，监听被关联对象是否被回收
通过WeakReference创建弱引用，不管内存是否充足，被关联的对象在gc时都会被回收；可以通过get()获取被关联对象，与引用队列一起使用，监听被关联对象是否被回收
通过PhantomReference创建虚引用，被关联的对象在任何时候都可能被回收；不影响被关联对象的生命周期，无法通过get()获取被关联对象；必须与引用队列一起使用，可以跟踪对象是否被垃圾回收

引用队列：

实现对Reference对象的管理，避免大量Reference对象累积，造成内存泄漏
若引用不与引用队列关联，生命周期为：start —> active —> inactive —> 垃圾回收
若引用与引用队列关联，生命周期为：start —> active —> pending —> enqueued —> inactive —> 垃圾回收

虚引用的实际应用场景：FileCleaningTracker类

将文件与Object对象marker绑定，巧妙地借助marker的引用为虚引用，达到marker回收后，自动清理文件的目的

晓之木初

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
5
评论
结合代码理解java的四种引用类型

1. 絮絮叨叨在工作中使用到了ThreadLocal，在学习ThreadLocal的过程中，自己发现Java的引用类型是一个基础知识而自己对Java的四种引用类型忘得差不多了，只知道一些概念，具体每种类型的特点一点都不知道 ????于是，抽空复习了一下Java的四种引用类型（其实是学习，太菜了）通过结合代码的方式，去理解、验证每种引用类型。1.1 Java基本数据类型和引用类型的内存结构说到JVM，肯定少不了内存结构、垃圾回收机制等给个自己之前博客的链接：Java内存结构、垃圾回收机制
复制链接

扫一扫