简介
说明
本文用示例介绍Java中的引用类型的区别及使用。
从JDK 1.2版本开始，对象的引用被划分为4种级别，由高到低依次为：强引用、软引用、弱引用和虚引用。
本内容也是Java后端面试常见的问题。
为什么分为四种引用类型？
Java设计这四种引用的主要目的有两个：
- 可以让程序员通过代码的方式来决定某个对象的生命周期
- 有利于垃圾回收
引用类型简介
- 强引用
- 强引用是使用最普遍的引用，我们写的代码，99.9999%都是强引用
- 只要某个对象有强引用与之关联，这个对象永远不会被回收，即使内存不足，JVM宁愿抛出OOM，也不会去回收。
- 软引用
- 只有在内存不足时，JVM才会回收该对象。
- 当内存不足时，会触发JVM的GC，如果GC后，内存还是不足，就会把软引用包裹的对象给干掉。
- 弱引用
- 不管内存是否足够，只要发生GC，弱引用就会被回收。
- 虚引用
- 无法通过虚引用来获取对一个对象的真实引用。
- 虚引用必须与ReferenceQueue一起使用。当GC准备回收一个对象时，如果发现它还有虚引用，就会在回收之前，把这个虚引用加入到与之关联的ReferenceQueue中。
强引用
简介
强引用是使用最普遍的引用，我们写的代码，99.9999%都是强引用。
只要某个对象有强引用与之关联，这个对象永远不会被回收，即使内存不足，JVM宁愿抛出OOM，也不会去回收。
强引用写法：Object o = new Object();
让强引用的对象被回收的写法：o = null;
代码实例
用代码展示回收强引用的对象。
finalize方法在垃圾回收的时候会被调用。
package com.example.a;
class User{
@Override
protected void finalize() {
System.out.println("User 被回收了");
}
}
public class Demo {
public static void main(String[] args) {
User user = new User();
user = null;
System.gc();
}
}
结果
User 被回收了
总结
- 可以看到资源被回收了。
- 在实际开发中，不要重写finalize方法
- 在实际开发中，若看到有对象被手动赋值为null，很大可能就是为了“特意提醒”JVM这块资源可以进行垃圾回收了。
软引用
简介
说明
只有在内存不足时，JVM才会回收该对象。
当内存不足时，会触发JVM的GC，如果GC后，内存还是不足，就会把软引用包裹的对象给干掉。
应用场景：
软引用主要用于缓存：当内存足够时，可以正常的拿到缓存，当内存不够时，就会先干掉缓存，不至于马上抛出OOM。
比如：浏览器的后退按钮。按后退时，这个后退时显示的网页内容是重新进行请求还是从缓存中取出呢？这就要看具体的实现策略了。
- 如果一个网页在浏览结束时就进行内容的回收，则按后退查看前面浏览过的页面时，需要重新构建；
- 如果将浏览过的网页存储到内存中会造成内存的大量浪费，甚至会造成内存溢出。
这时候就可以使用软引用，很好的解决了实际的问题：
// 获取浏览器对象进行浏览
Browser browser = new Browser();
// 从后台程序加载浏览页面
BrowserPage page = browser.getPage();
// 将浏览完毕的页面置为软引用
SoftReference softReference = new SoftReference(page);
// 回退或者再次浏览此页面时
if(softReference.get() != null) {
// 内存充足，还没有被回收器回收，直接获取缓存
page = softReference.get();
} else {
// 内存不足，软引用的对象已经回收
page = browser.getPage();
// 重新构建软引用
softReference = new SoftReference(page);
}
代码实例
代码写法
创建一个软引用：
SoftReference<User> softReference = new SoftReference<User>(new User());
从软引用对象获得包裹的对象：
User User = softReference.get(); System.out.println(User);
实例：用代码展示回收软引用的对象
定义一个软引用对象，里面包裹了byte[]，byte[]占用了10M，然后又创建了10Mbyte[]。
package com.example.a;
import java.lang.ref.SoftReference;
public class Demo {
public static void main(String[] args) {
SoftReference<byte[]> softReference = new SoftReference<byte[]>(new byte[1024*1024*10]);
System.out.println(softReference.get());
System.gc();
System.out.println(softReference.get());
byte[] bytes = new byte[1024 * 1024 * 10];
System.out.println(softReference.get());
}
}
执行结果
[B@1b6d3586 [B@1b6d3586 [B@1b6d3586
现在我们手动制造内存不足：设置最大堆大小为15M：-Xmx15m
法1：先编译程序，再java -Xmx15m xxx
法2：Idea指定参数
执行结果
[B@1b6d3586 [B@1b6d3586 null
结论
手动GC后，软引用对象包裹的byte[]还活的好好的，但是当我们创建了一个10M的byte[]后，最大堆内存不够了，所以JVM把软引用对象包裹的byte[]给干掉了。
弱引用
简介
说明
不管内存是否足够，只要发生GC，弱引用就会被回收。
使用场景
若引用主要用于缓存：当没有发生GC时，可以正常的拿到缓存，当发生GC时，就会先干掉缓存，不至于马上抛出OOM。
JDK里对弱引用的使用：ThreadLocal、WeakHashMap。
如果一个对象是偶尔(很少)的使用，并且希望在使用时随时就能获取到，但又不想影响此对象的垃圾收集，就可以使用弱引用。
代码实例
代码写法
弱引用的使用和软引用类似，只是关键字变成了WeakReference
创建一个弱引用：
WeakReference<User> weakReference = new WeakReference<User>(new User());
从弱引用对象获得包裹的对象：
User User = weakReference.get(); System.out.println(User);
实例：用代码展示回收弱引用的对象
package com.example.a;
import java.lang.ref.WeakReference;
public class Demo {
public static void main(String[] args) {
WeakReference<byte[]> weakReference = new WeakReference<byte[]>(new byte[1]);
System.out.println(weakReference.get());
System.gc();
System.out.println(weakReference.get());
}
}
结果
[B@1b6d3586 null
结论
不管内存是否足够，只要发生GC，弱引用就会被回收。
虚引用
简介
说明
无法通过虚引用来获取对一个对象的真实引用。
虚引用必须与ReferenceQueue一起使用。当GC准备回收一个对象时，如果发现它还有虚引用，就会在回收之前，把这个虚引用加入到与之关联的ReferenceQueue中。
使用场景
虚引用主要用来跟踪对象被垃圾回收器回收的活动。
程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要进行垃圾回收。如果程序发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。
NIO运用了虚引用管理堆外内存。
代码实例
简单实例
package com.example.a;
import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;
public class Demo {
public static void main(String[] args) {
ReferenceQueue queue = new ReferenceQueue();
PhantomReference<byte[]> reference = new PhantomReference<byte[]>(new byte[1], queue);
System.out.println(reference.get());
}
}
结果
null
看源码：竟然直接返回了null。
这就是虚引用特点之一：无法通过虚引用来获取对一个对象的真实引用。
实例：用代码展示回收虚引用的对象
package com.example.a;
import java.lang.ref.PhantomReference;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
class User {
@Override
protected void finalize() {
System.out.println("User 被回收了");
}
}
public class Demo {
public static void main(String[] args) {
ReferenceQueue queue = new ReferenceQueue();
List<byte[]> bytes = new ArrayList<>();
PhantomReference<User> phantomReference = new PhantomReference<User>(new User(), queue);
new Thread(() -> {
for (int i = 0; i < 100; i++) {
bytes.add(new byte[1024 * 1024]);
}
}).start();
new Thread(() -> {
while (true) {
Reference poll = queue.poll();
if (poll != null) {
System.out.println("虚引用被回收了：" + poll);
}
}
}).start();
Scanner scanner = new Scanner(System.in);
scanner.hasNext();
}
}
我们手动制造内存不足：设置最大堆大小为15M：-Xmx15m
结果：
User 被回收了 Exception in thread "Thread-0" java.lang.OutOfMemoryError: Java heap space at com.example.a.Demo.lambda$main$0(Demo.java:24) at com.example.a.Demo$$Lambda$1/2003749087.run(Unknown Source) at java.lang.Thread.run(Thread.java:748) 虚引用被回收了：java.lang.ref.PhantomReference@2c4772fc
请先 ！