一、JVM引用类型初相识
在Java的世界里，JVM（Java虚拟机）就像是一个大管家，负责管理程序运行时的内存。而JVM的引用类型就像是不同种类的“绳子”，它们用来“绑住”内存中的对象。这些“绳子”有强、软、弱、虚四种，每种都有自己的特点和用途。
强引用
强引用就像是一根非常结实的绳子，只要这根绳子还在，它绑着的对象就不会被JVM回收。比如说，我们平时创建对象时用的就是强引用。
// Java技术栈示例
// 创建一个强引用的对象
Object strongObject = new Object();
// strongObject 是一个强引用，只要 strongObject 变量还在，它指向的对象就不会被垃圾回收
软引用
软引用就像是一根稍微细一点的绳子。当内存充足的时候，它绑着的对象不会被回收；但当内存紧张，快要不够用的时候，JVM就会把软引用指向的对象回收掉，以腾出内存空间。
// Java技术栈示例
import java.lang.ref.SoftReference;
// 创建一个软引用
SoftReference<Object> softReference = new SoftReference<>(new Object());
// 当内存不足时，JVM可能会回收软引用指向的对象
弱引用
弱引用就像是一根很细的线，只要进行垃圾回收，不管内存够不够用，它绑着的对象都会被回收。
// Java技术栈示例
import java.lang.ref.WeakReference;
// 创建一个弱引用
WeakReference<Object> weakReference = new WeakReference<>(new Object());
// 只要发生垃圾回收，弱引用指向的对象就可能被回收
虚引用
虚引用就像是一根几乎不存在的“绳子”，它主要用于跟踪对象被垃圾回收的状态。虚引用指向的对象随时可能被回收，而且它不能单独使用，必须和引用队列一起使用。
// Java技术栈示例
import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;
// 创建引用队列
ReferenceQueue<Object> referenceQueue = new ReferenceQueue<>();
// 创建虚引用
PhantomReference<Object> phantomReference = new PhantomReference<>(new Object(), referenceQueue);
// 虚引用主要用于在对象被回收时得到通知
二、应用场景大揭秘
强引用的应用场景
强引用是我们最常用的引用类型，它适用于那些必须一直存在于内存中的对象。比如说，在一个电商系统中，用户登录后，用户的信息对象就会被强引用，这样在用户操作过程中，这些信息一直都在，不会被回收。
// Java技术栈示例
class User {
private String name;
private int age;
public User(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
}
public class StrongReferenceExample {
public static void main(String[] args) {
// 创建一个用户对象并使用强引用
User user = new User("张三", 25);
// 在程序运行过程中，user 对象会一直存在，直到不再被引用
System.out.println("用户姓名：" + user.getName());
System.out.println("用户年龄：" + user.getAge());
}
}
软引用的应用场景
软引用适合用于缓存场景。比如说，在一个图片浏览器中，我们可以把图片缓存起来，当内存充足时，图片会一直存在于缓存中；当内存不足时，这些缓存的图片就会被回收。
// Java技术栈示例
import java.lang.ref.SoftReference;
import java.util.HashMap;
import java.util.Map;
// 图片缓存类
class ImageCache {
private Map<String, SoftReference<Image>> cache = new HashMap<>();
public void put(String key, Image image) {
cache.put(key, new SoftReference<>(image));
}
public Image get(String key) {
SoftReference<Image> softReference = cache.get(key);
if (softReference != null) {
return softReference.get();
}
return null;
}
}
// 图片类
class Image {
private String name;
public Image(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
public class SoftReferenceExample {
public static void main(String[] args) {
ImageCache cache = new ImageCache();
Image image = new Image("风景图");
// 将图片放入缓存
cache.put("风景图", image);
// 从缓存中获取图片
Image cachedImage = cache.get("风景图");
if (cachedImage != null) {
System.out.println("从缓存中获取到图片：" + cachedImage.getName());
}
}
}
弱引用的应用场景
弱引用常用于解决内存泄漏问题。比如说，在一个监听器模式中，如果使用强引用，当监听器不再使用时，由于强引用的存在，监听器对象不会被回收，可能会导致内存泄漏。而使用弱引用就可以避免这个问题。
// Java技术栈示例
import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.List;
// 监听器接口
interface Listener {
void onEvent();
}
// 事件源类
class EventSource {
private List<WeakReference<Listener>> listeners = new ArrayList<>();
public void addListener(Listener listener) {
listeners.add(new WeakReference<>(listener));
}
public void fireEvent() {
for (WeakReference<Listener> weakReference : listeners) {
Listener listener = weakReference.get();
if (listener != null) {
listener.onEvent();
}
}
}
}
// 具体监听器类
class ConcreteListener implements Listener {
@Override
public void onEvent() {
System.out.println("监听到事件");
}
}
public class WeakReferenceExample {
public static void main(String[] args) {
EventSource eventSource = new EventSource();
ConcreteListener listener = new ConcreteListener();
// 添加监听器
eventSource.addListener(listener);
// 触发事件
eventSource.fireEvent();
// 让监听器对象可以被回收
listener = null;
// 触发垃圾回收
System.gc();
// 再次触发事件
eventSource.fireEvent();
}
}
虚引用的应用场景
虚引用主要用于在对象被垃圾回收时进行一些清理工作。比如说，在一个文件资源管理系统中，当文件对象被回收时，我们可以使用虚引用来释放文件资源。
// Java技术栈示例
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;
// 文件资源管理类
class FileResourceManager {
private ReferenceQueue<FileInputStream> referenceQueue = new ReferenceQueue<>();
private Thread cleanerThread;
public FileResourceManager() {
cleanerThread = new Thread(() -> {
while (true) {
try {
PhantomReference<FileInputStream> phantomReference = (PhantomReference<FileInputStream>) referenceQueue.remove();
// 释放文件资源
FileInputStream fis = phantomReference.get();
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
});
cleanerThread.setDaemon(true);
cleanerThread.start();
}
public FileInputStream openFile(String filePath) throws IOException {
File file = new File(filePath);
FileInputStream fis = new FileInputStream(file);
new PhantomReference<>(fis, referenceQueue);
return fis;
}
}
public class PhantomReferenceExample {
public static void main(String[] args) {
FileResourceManager manager = new FileResourceManager();
try {
FileInputStream fis = manager.openFile("test.txt");
// 使用文件输入流
// ...
// 让文件输入流对象可以被回收
fis = null;
// 触发垃圾回收
System.gc();
} catch (IOException e) {
e.printStackTrace();
}
}
}
三、技术优缺点分析
强引用
- 优点：强引用可以确保对象一直存在于内存中，保证程序的正常运行。
- 缺点：如果强引用过多，可能会导致内存占用过高，甚至出现内存溢出的问题。
软引用
- 优点：在内存充足时可以缓存对象，提高程序的性能；当内存不足时，会自动回收对象，避免内存溢出。
- 缺点：由于软引用的回收是由JVM根据内存情况决定的，所以不能精确控制对象的回收时间。
弱引用
- 优点：可以有效避免内存泄漏问题，当对象不再被强引用时，弱引用指向的对象会被及时回收。
- 缺点：弱引用的生命周期比较短，可能会导致对象过早被回收，影响程序的正常运行。
虚引用
- 优点：可以在对象被回收时进行一些清理工作，确保资源的正确释放。
- 缺点：虚引用不能单独使用，必须和引用队列一起使用，使用起来相对复杂。
四、注意事项
强引用
- 要注意避免创建过多的强引用对象，以免导致内存占用过高。
- 在对象不再使用时，要及时将强引用置为null，让对象可以被垃圾回收。
软引用
- 要根据实际情况合理设置缓存的大小，避免缓存过多对象导致内存不足。
- 要注意软引用对象的回收时间，不能依赖软引用对象一直存在。
弱引用
- 要注意弱引用对象可能会过早被回收，在使用弱引用对象时要进行空值判断。
- 要避免在弱引用对象被回收后继续使用该对象。
虚引用
- 要确保引用队列的处理线程正常运行，否则可能会导致资源无法及时释放。
- 虚引用的使用相对复杂，要仔细考虑是否真的需要使用虚引用。
五、文章总结
JVM的引用类型（强、软、弱、虚）在Java程序中有着重要的作用。强引用适用于需要一直存在于内存中的对象；软引用适合用于缓存场景，可以在内存充足时缓存对象，在内存不足时自动回收；弱引用可以有效避免内存泄漏问题；虚引用主要用于在对象被回收时进行一些清理工作。我们在使用这些引用类型时，要根据实际情况选择合适的引用类型，并注意它们的优缺点和使用注意事项，这样才能有效管理内存，避免内存泄漏，提高程序的性能和稳定性。
评论