你不可不知的Java引用类型之——软引用
定义
软引用是使用SoftReference创建的引用,强度弱于强引用,被其引用的对象在内存不足的时候会被回收,不会产生内存溢出。
说明
软引用,顾名思义就是比较“软”一点的引用。
当一个对象与GC Roots之间存在强引用时,无论何时都不会被GC回收掉。如果一个对象与GC Roots之间没有强引用与其关联而存在软引用关联时,那么垃圾回收器对它的态度就取决于内存的紧张程度了。如果内存空间足够,垃圾回收器就不会回收这个对象,但如果内存空间不足了,它就难逃被回收的厄运。
如果一个对象与GC Roots之间不存在强引用,但是存在软引用,则称这个对象为软可达(soft reachable)
对象。
在垃圾回收器没有回收它的时候,软可达对象就像强可达对象一样,可以被程序正常访问和使用,但是需要通过软引用对象间接访问,需要的话也能重新使用强引用将其关联。所以软引用适合用来做内存敏感的高速缓存。
String s = new String("Frank"); // 创建强引用与String对象关联,现在该String对象为强可达状态
SoftReference<String> softRef = new SoftReference<String>(s); // 再创建一个软引用关联该对象
s = null; // 消除强引用,现在只剩下软引用与其关联,该String对象为软可达状态
s = softRef.get(); // 重新关联上强引用
这里变量s持有对字符串对象的强引用,而softRef持有对该对象的软引用,所以当执行s = null后,字符串对象就只剩下软引用了,这时如果因为内存不足发生Full GC,就会把这个字符串对象回收掉。
注意,在垃圾回收器回收一个对象前,SoftReference类所提供的get方法会返回Java对象的强引用,一旦垃圾线程回收该对象之后,get方法将返回null。所以在获取软引用对象的代码中,一定要先判断返回是否为null,以免出现NullPointerException异常而导致应用崩溃。
下面的代码会让s再次持有对象的强引用:
s = softRef.get();
如果在softRef指向的对象被回收前,用强引用指向该对象,那这个对象又会变成强可达。
来看一个使用SoftReference的栗子:
public class TestA {
static class OOMClass{
private int[] oom = new int[1024 * 100];// 100KB
}
public static void main(String[] args) throws InterruptedException {
ReferenceQueue<OOMClass> queue = new ReferenceQueue<>();
List<SoftReference> list = new ArrayList<>();
while(true){
for (int i = 0; i < 100; i++) {
list.add(new SoftReference<OOMClass>(new OOMClass(), queue));
}
Thread.sleep(500);
}
}
}
注意,ReferenceQueue中声明的类型为OOMClass,即与SoftReference引用的类型一致。
设置一下虚拟机参数:
-verbose:gc -Xms4m -Xmx4m -Xmn2m
运行结果:
[GC (Allocation Failure) 1017K->432K(3584K), 0.0017239 secs]
[GC (Allocation Failure) 1072K->472K(3584K), 0.0099237 secs]
[GC (Allocation Failure) 1323K->1296K(3584K), 0.0009528 secs]
[GC (Allocation Failure) 2114K->2136K(3584K), 0.0009951 secs]
[Full GC (Ergonomics) 2136K->1992K(3584K), 0.0040658 secs]
[Full GC (Ergonomics) 2807K->2791K(3584K), 0.0036280 secs]
[Full GC (Allocation Failure) 2791K->373K(3584K), 0.0032477 secs]
[Full GC (Ergonomics) 2786K->2773K(3584K), 0.0034554 secs]
[Full GC (Allocation Failure) 2773K->373K(3584K), 0.0032667 secs]
[Full GC (Ergonomics) 2798K->2775K(3584K), 0.0036231 secs]
[Full GC (Allocation Failure) 2775K->375K(3584K), 0.0055482 secs]
[Full GC (Ergonomics) 2799K->2776K(3584K), 0.0031358 secs]
...省略n次GC信息
在TestA中,我们使用死循环不断的往list中添加新对象,如果是强引用,会很快因为内存不足而抛出OOM,因为这里的堆内存大小设置为了4M,而一个对象就有100KB,一个循环添加100个对象,也就是差不多10M,显然一个循环都跑不完就会内存不足,而这里,因为使用的是软引用,所以JVM会在内存不足的时候将软引用回收掉。
[Full GC (Allocation Failure) 2791K->373K(3584K), 0.0032477 secs]
从这一条可以看出,在内存不足发生Full GC时,回收掉了大部分的软引用指向的对象,释放了大量的内存。
因为这里新生代只分配了2M,所以很快就会发生GC,如果你的程序运行没有看到这个结果,请先确认一下虚拟机参数是否设置正确,如果设置正确还是没有看到,那么将循环次数由1000改为10000或者100000在试试看。
应用场景
软引用关联的对象,只有在内存不足的时候JVM才会回收该对象。这一点可以很好地用来解决OOM的问题,并且这个特性很适合用来实现缓存:比如网页缓存、图片缓存等。
现在考虑这样一个场景 ,在很多应用中,都会出现大量的默认图片,比如说QQ的默认头像,应用内的默认图标等等,这些图片很多地方会用到。
如果每次都去读取图片,由于读取文件速度较慢,大量重复的读取会导致性能下降。所以可以考虑将图片缓存起来,需要的时候直接从内存中读取。但是,由于图片占用内存空间比较大,缓存的图片过多会占用比较多的内存,就可能比较容易发生OOM。这时候,软引用就派得上用场了。
注意,SoftReference对象是用来保存软引用的,但它同时也是一个Java对象。所以,当软可及对象被回收之后,虽然这个SoftReference对象的get()方法返回null,但SoftReference对象本身并不是null,而此时这个SoftReference对象已经不再具有存在的价值,需要一个适当的清除机制,避免大量SoftReference对象带来的内存泄漏。
ReferenceQueue就是用来保存这些需要被清理的引用对象的。软引用可以和一个引用队列(ReferenceQueue)联合使用,如果软引用所引用的对象被垃圾回收器回收,Java虚拟机就会把这个软引用加入到与之关联的引用队列中。
下面用SoftReference来实现一个简单的缓存类:
public class SoftCache<T> {
// 引用队列
private ReferenceQueue<T> referenceQueue = new ReferenceQueue<>();
// 保存软引用集合,在引用对象被回收后销毁
private List<Reference<T>> list = new ArrayList<>();
// 添加缓存对象
public synchronized void add(T obj){
// 构建软引用
Reference<T> reference = new SoftReference<T>(obj, referenceQueue);
// 加入列表中
list.add(reference);
}
// 获取缓存对象
public synchronized T get(int index){
// 先对无效引用进行清理
clear();
if (index < 0 || list.size() < index){
return null;
}
Reference<T> reference = list.get(index);
return reference == null ? null : reference.get();
}
public int size(){
return list.size();
}
@SuppressWarnings("unchecked")
private void clear(){
Reference<T> reference;
while (null != (reference = (Reference<T>) referenceQueue.poll())){
list.remove(reference);
}
}
}
然后测试一下这个缓存类:
public class SoftCacheTest {
private static int num = 0;
public static void main(String[] args){
SoftCache<OOMClass> softCache = new SoftCache<>();
for (int i = 0; i < 40; i++) {
softCache.add(new OOMClass("OOM Obj-" + ++num));
}
System.out.println(softCache.size());
for (int i = 0; i < softCache.size(); i++) {
OOMClass obj = softCache.get(i);
System.out.println(obj == null ? "null" : obj.name);
}
System.out.println(softCache.size());
}
static class OOMClass{
private String name;
private int[] oom = new int[1024 * 100];// 100KB
public OOMClass(String name) {
this.name = name;
}
}
}
仍使用之前的虚拟机参数:
-verbose:gc -Xms4m -Xmx4m -Xmn2m
运行结果:
[GC (Allocation Failure) 1017K->432K(3584K), 0.0012236 secs]
[GC (Allocation Failure) 1117K->496K(3584K), 0.0016875 secs]
[GC (Allocation Failure) 1347K->1229K(3584K), 0.0015059 secs]
[GC (Allocation Failure) 2047K->2125K(3584K), 0.0018090 secs]
[Full GC (Ergonomics) 2125K->1994K(3584K), 0.0054759 secs]
[Full GC (Ergonomics) 2822K->2794K(3584K), 0.0023167 secs]
[Full GC (Allocation Failure) 2794K->376K(3584K), 0.0036056 secs]
[Full GC (Ergonomics) 2795K->2776K(3584K), 0.0042365 secs]
[Full GC (Allocation Failure) 2776K->376K(3584K), 0.0035122 secs]
[Full GC (Ergonomics) 2795K->2776K(3584K), 0.0054760 secs]
[Full GC (Allocation Failure) 2776K->376K(3584K), 0.0036965 secs]
[Full GC (Ergonomics) 2802K->2777K(3584K), 0.0044513 secs]
[Full GC (Allocation Failure) 2777K->376K(3584K), 0.0041400 secs]
[Full GC (Ergonomics) 2796K->2777K(3584K), 0.0025255 secs]
[Full GC (Allocation Failure) 2777K->376K(3584K), 0.0037690 secs]
[Full GC (Ergonomics) 2817K->2777K(3584K), 0.0037759 secs]
[Full GC (Allocation Failure) 2777K->377K(3584K), 0.0042416 secs]
缓存列表大小:40
OOM Obj-37
OOM Obj-38
OOM Obj-39
OOM Obj-40
缓存列表大小:4
可以看到,缓存40个软引用对象之后,如果一次性全部存储,显然内存大小无法满足,所以在不断创建软引用对象的过程中,不断发生GC来进行垃圾回收,最终只有4个软引用未被清理掉。
强引用与软引用对比
没有对比就没有伤害,来将强引用和软引用对比一下:
public class Test {
static class OOMClass{
private int[] oom = new int[1024];
}
public static void main(String[] args) {
testStrongReference();
//testSoftReference();
}
public static void testStrongReference(){
List<OOMClass> list = new ArrayList<>();
for (int i = 0; i < 1000; i++) {
list.add(new OOMClass());
}
}
public static void testSoftReference(){
ReferenceQueue<OOMClass> referenceQueue = new ReferenceQueue<>();
List<SoftReference> list = new ArrayList<>();
for (int i = 0; i < 1000; i++) {
OOMClass oomClass = new OOMClass();
list.add(new SoftReference(oomClass, referenceQueue));
oomClass = null;
}
}
}
运行testStrongReference方法的结果如下:
[GC (Allocation Failure) 1019K->384K(3584K), 0.0033595 secs]
[GC (Allocation Failure) 1406K->856K(3584K), 0.0013098 secs]
[GC (Allocation Failure) 1880K->1836K(3584K), 0.0014382 secs]
[Full GC (Ergonomics) 1836K->1756K(3584K), 0.0039761 secs]
[Full GC (Ergonomics) 2778K->2758K(3584K), 0.0021269 secs]
[Full GC (Ergonomics) 2779K->2770K(3584K), 0.0016329 secs]
[Full GC (Ergonomics) 2779K->2775K(3584K), 0.0023157 secs]
[Full GC (Ergonomics) 2775K->2775K(3584K), 0.0015927 secs]
[Full GC (Ergonomics) 3037K->3029K(3584K), 0.0025071 secs]
[Full GC (Ergonomics) 3067K->3065K(3584K), 0.0017529 secs]
[Full GC (Allocation Failure) 3065K->3047K(3584K), 0.0033445 secs]
[Full GC (Ergonomics) 3068K->3059K(3584K), 0.0016623 secs]
[Full GC (Ergonomics) 3070K->3068K(3584K), 0.0028357 secs]
[Full GC (Allocation Failure) 3068K->3068K(3584K), 0.0017616 secs]
java.lang.OutOfMemoryError: Java heap space
Dumping heap to java_pid3352.hprof ...
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
Heap dump file created [3855956 bytes in 0.017 secs]
[Full GC (Ergonomics) 3071K->376K(3584K), 0.0032068 secs]
at reference.Test$OOMClass.<init>(Test.java:11)
at reference.Test.testStrongReference(Test.java:22)
at reference.Test.main(Test.java:15)
Process finished with exit code 1
可以看到,很快就抛出了OOM,原因是Java heap space,也就是堆内存不足。
如果运行testSoftReference方法,将会得到如下结果:
[GC (Allocation Failure) 1019K->464K(3584K), 0.0019850 secs]
[GC (Allocation Failure) 1484K->844K(3584K), 0.0015920 secs]
[GC (Allocation Failure) 1868K->1860K(3584K), 0.0043236 secs]
[Full GC (Ergonomics) 1860K->1781K(3584K), 0.0044581 secs]
[Full GC (Ergonomics) 2802K->2754K(3584K), 0.0041726 secs]
[Full GC (Ergonomics) 2802K->2799K(3584K), 0.0031293 secs]
[Full GC (Ergonomics) 3023K->3023K(3584K), 0.0024830 secs]
[Full GC (Ergonomics) 3071K->3068K(3584K), 0.0035025 secs]
[Full GC (Allocation Failure) 3068K->405K(3584K), 0.0040672 secs]
[GC (Allocation Failure) 1512K->1567K(3584K), 0.0011170 secs]
[Full GC (Ergonomics) 1567K->1496K(3584K), 0.0048438 secs]
可以看到,并没有抛出OOM,而是进行多次了GC,可以明显的看到这一条:
[Full GC (Allocation Failure) 3068K->405K(3584K), 0.0040672 secs]
当内存不足时进行了一次Full GC,回收了大部分内存空间,也就是将大部分软引用指向的对象回收掉了。
小结
- 软引用弱于强引用
- 软引用指向的对象会在内存不足时被垃圾回收清理掉
- JVM会优先回收长时间闲置不用的软引用对象,对那些刚刚构建的或刚刚使用过的软引用对象会尽可能保留
- 软引用可以有效的解决OOM问题
- 软引用适合用作非必须大对象的缓存
至此,本篇就告一段落了,这里只简单的介绍了软引用的作用以及用法。其实软引用并没有这么好,它的使用有一些可能是致命的缺点,如果想要更深入的了解软引用的运行原理以及软引用到底是在何时进行回收,又是如何进行回收的话,可以查看翻阅后续的章节。
你不可不知的Java引用类型之——软引用的更多相关文章
- Java引用类型之软引用(2)
下面接着上一篇介绍第2阶段和第3阶段的处理逻辑. 2.process_phase2() 第2个阶段移除所有的referent还存活的Reference,也就是从refs_list中移除Referenc ...
- 你不可不知的Java引用类型之——虚引用
定义 虚引用是使用PhantomReference创建的引用,虚引用也称为幽灵引用或者幻影引用,是所有引用类型中最弱的一个.一个对象是否有虚引用的存在,完全不会对其生命周期构成影响,也无法通过虚引用获 ...
- 你不可不知的Java引用类型之——弱引用
定义 弱引用是使用WeakReference创建的引用,弱引用也是用来描述非必需对象的,它是比软引用更弱的引用类型.在发生GC时,只要发现弱引用,不管系统堆空间是否足够,都会将对象进行回收. 说明 弱 ...
- Java引用类型之软引用(1)
Java使用SoftReference来表示软引用,软引用是用来描述一些“还有用但是非必须”的对象.对于软引用关联着的对象,在JVM应用即将发生内存溢出异常之前,将会把这些软引用关联的对象列进去回收对 ...
- 你不可不知的Java引用类型之——强引用
定义 强引用是使用最普遍的引用.如果一个对象具有强引用,那垃圾回收器宁愿抛出OOM(OutOfMemoryError)也不会回收它. 说明 不要被这个强字吓到,以为这个引用就很厉害,其实强引用就是程序 ...
- Java引用类型之弱引用与幻像引用
这一篇将介绍弱引用和幻像引用. 1.WeakReference WeakReference也就是弱引用,弱引用和软引用类似,它是用来描述"非必须"的对象的,它的强度比软引用要更弱一 ...
- Java引用类型之最终引用
FinalReference类只有一个子类Finalizer,并且Finalizer由关键字final修饰,所以无法继承扩展.类的定义如下: class FinalReference<T> ...
- Java基础 之软引用、弱引用、虚引用 ·[转载]
Java基础 之软引用.弱引用.虚引用 ·[转载] 2011-11-24 14:43:41 Java基础 之软引用.弱引用.虚引用 浏览(509)|评论(1) 交流分类:Java|笔记分类: Ja ...
- 你不可不知的Java引用类型之——Reference源码解析
定义 Reference是所有引用类型的父类,定义了引用的公共行为和操作. reference指代引用对象本身,referent指代reference引用的对象,下文介绍会以reference,ref ...
随机推荐
- Springboot中读取.yml文件
自定义配置文件application-dev.yml spring: dataresource: druid: driver-class-name: com.mysql.jdbc.Driver url ...
- JS特效实现微博评论逻辑
实现代码: <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF ...
- vue中axios的安装和使用
有很多时候你在构建应用时需要访问一个 API 并展示其数据.做这件事的方法有好几种,而使用基于 promise 的 HTTP 客户端 axios 则是其中非常流行的一种. 安装包:如果没有安装cnpm ...
- 使用request爬取拉钩网信息
通过cookies信息爬取 分析header和cookies 通过subtext粘贴处理header和cookies信息 处理后,方便粘贴到代码中 爬取拉钩信息代码 import requests c ...
- Eclipse 项目导入 Android Studio 导致的乱码问题
最近有一个 Eclipse 项目导入 Android Studio 1.4 时出现乱码,Build 提示 Error:(38, 5) 閿欒: 缂栫爜UTF-8鐨勪笉鍙槧灏勫瓧绗?. 源代码是 GB ...
- Django+JWT实现Token认证
对外提供API不用django rest framework(DRF)就是旁门左道吗? 基于Token的鉴权机制越来越多的用在了项目中,尤其是对于纯后端只对外提供API没有web页面的项目,例如我们通 ...
- Java并发编程笔记之FutureTask源码分析
FutureTask可用于异步获取执行结果或取消执行任务的场景.通过传入Runnable或者Callable的任务给FutureTask,直接调用其run方法或者放入线程池执行,之后可以在外部通过Fu ...
- maven自动部署项目以及常见问题解决
Maven自动部署war到Tomcat1. 在maven项目的pom里配置如下信息 <build> <finalName>dianxiao</finalName> ...
- Oracle添加定时任务
1.创建存储过程 注:执行语句后,如果需要请添加commit 2.添加定时job,执行存储过程 declare job_delete number; begin dbms_job.submit( jo ...
- Fibonacci快速实现(优化)
斐波那契数列的通俗解法是利用递推公式进行递归求解,我们可以更优化的去解决它. 方法一:通项公式 斐波那契数列的递推公式是f(n)=f(n-1)+f(n-2),特征方程为:x2=x+1,解该方程得(1+ ...