简单直白教你理解Java中四大引用强引用,软引用,弱引用,虚引用
2017-05-03 23:54
323 查看
我属于自学型的,所以知识不够系统,只能是一边儿工作一边查漏补缺,在此要对那些写技术文章的人由衷的说句谢谢,谢谢各位大神们的分享
在此说明一下,StrongReference只是对强引用的一个称呼,但是强引用没有对应的实体类。使用强引用的对象就算是内存出现outofmemory(内存溢出)
的异常也不会回收。也就是说该对象永远不会被垃圾回收器回收,不论内存是否充足。平常代码中用的最多的就是强引用。
Demo验证:
[java] view
plain copy
static Object object = new Object();
....................................
/**
* 强引用
*/
public static void testStrongReference(){
Object obj = object;
object = null;
System.gc();
System.out.print("after system.gc-strongReference---obj = " + obj);
}
输出结果
在该demo中obj就是使用的默认的强引用,虽然obj所指向的对象被置为null,但gc不会回收该强引用对象
软引用有对应的实体列为SoftReference,使用软引用引用的对象只有在程序发生oom异常前才会回收,也就是说如果内存充足永远不会被回收,只有在内存不足时才会回收,很好的避免oom,非常适合做缓存。
Demo验证
[java] view
plain copy
/**
* 软引用
*/
public static void testSoftReference(){
SoftReference<Object> obj = new SoftReference<>(object);
object = null;
System.gc();
System.out.print("after system.gc---softReference = " + obj); }
由控制台的输出结果可以看到,虽然软引用引用的对象被清空,但是由于内存充足,就算是执行了gc也不会被回收。
小结一下:由以上的demo可以看到软引用和强引用在内存充足的情况下是一样的都不会被回收,只有在内存不足时软引用才会被及时回收避免oom异常,而强引用却很霸道坚决不回收。这样分析来看,使用软引用可以很好的避免oom异常,适合做一些缓存工作
[java] view
plain copy
Demo验证:
第一种情况,如果把弱引用所引用的对象置为null,但不进行gc,弱引用的get到的会是null吗?
[java] view
plain copy
public static void testWeakReference(){
WeakReference<Object> weakReference = new WeakReference<Object>(object);
WeakReference<Object> weakReferenceStr = new WeakReference<Object>(str);
object = null;
str = null;
/ System.gc();
System.out.println("after system.gc---weakReference = " + weakReference.get());
System.out.print("after system.gc---weakReferenceStr = " + weakReferenceStr.get());
}
输出结果为:
[java] view
plain copy
after system.gc---weakReference = java.lang.Object@14ae5a5
after system.gc---weakReferenceStr = strTest
Process finished with exit code 0
可以看到如果不进行gc,弱引用对象在内存充足的情况下是不会回收的,不论所引用的对象是否为null
第二种情况,不对所引用的对象置为null,直接进行gc
[java] view
plain copy
public static void testWeakReference(){
WeakReference<Object> weakReference = new WeakReference<Object>(object);
WeakReference<Object> weakReferenceStr = new WeakReference<Object>(str);
// object = null;
// str = null;
System.gc();
System.out.println("after system.gc---weakReference = " + weakReference.get());
System.out.print("after system.gc---weakReferenceStr = " + weakReferenceStr.get());
}
输出结果为
[java] view
plain copy
after system.gc---weakReference = java.lang.Object@14ae5a5
after system.gc---weakReferenceStr = strTest
Process finished with exit code 0
可以看到,此时所引用的对象不为null,所以在进行gc回收时不会回收弱引用对象。由此可以看出弱引用跟对象的生命周期有关,在对象不为null时,垃圾回收器不会回收弱引用
第三种情况
[java] view
plain copy
public static void testWeakReference(){
WeakReference<Object> weakReference = new WeakReference<Object>(object);
WeakReference<Object> weakReferenceStr = new WeakReference<Object>(str);
object = null;
str = null;
System.gc();
System.out.println("after system.gc---weakReference = " + weakReference.get());
System.out.print("after system.gc---weakReferenceStr = " + weakReferenceStr.get());
}
输出结果
[java] view
plain copy
after system.gc---weakReference = null
after system.gc---weakReferenceStr = strTest
Process finished with exit code 0
在这里说明一下str对象的定义方式
[java] view
plain copy
static String str = "strTest";
可以看到,使用new的方式构造的对象在置为null后,所对应的弱引用被回收,但是使用赋值的方式所获取的对象置为null后,所对应的弱引用没有被回收,这是为什么呢?这里暂且TODO该问题,把四大引用总结完后再研究
{add 2016-11-15
这是因为gc不清理常量池里的垃圾,所以所引用的内容不为null
}
综合以上三种情况,可以对弱引用下一个结论了,弱应用与对象的生命周期有关。在进行垃圾回收时,如果所引用的对象为null,则不论内存是否充足都会被回收,否则不会被回收。当然当内存不足时会直接被回收。
Demo验证
[java] view
plain copy
public static void testPhantonReference(){
ReferenceQueue<Object> referenceQueue = new ReferenceQueue<>();
PhantomReference<Object> phantomReference = new PhantomReference<>(object,referenceQueue);
PhantomReference<Object> phantomReferenceStr = new PhantomReference<>(str,referenceQueue);
// object = null;
// str = null;
System.gc();
System.out.println("after system.gc---phantomReference = " + phantomReference.get());
System.out.print("after system.gc---phantomReferenceStr = " + phantomReferenceStr.get());
}
输出结果如下
[java] view
plain copy
after system.gc---phantomReference = null
after system.gc---phantomReferenceStr = null
Process finished with exit code 0
可以看到,只要进行垃圾回收,虚引用就会被回收
总结:
对于垃圾回收器回收的顺序为
虚引用---弱引用----软引用---强引用。
多使用软引用做缓存可以很好地避免oom.
ONE,强引用(StrongReference)
概念介绍:在此说明一下,StrongReference只是对强引用的一个称呼,但是强引用没有对应的实体类。使用强引用的对象就算是内存出现outofmemory(内存溢出)
的异常也不会回收。也就是说该对象永远不会被垃圾回收器回收,不论内存是否充足。平常代码中用的最多的就是强引用。
Demo验证:
[java] view
plain copy
static Object object = new Object();
....................................
/**
* 强引用
*/
public static void testStrongReference(){
Object obj = object;
object = null;
System.gc();
System.out.print("after system.gc-strongReference---obj = " + obj);
}
输出结果
在该demo中obj就是使用的默认的强引用,虽然obj所指向的对象被置为null,但gc不会回收该强引用对象
TWO,软引用(SoftReference)
概念介绍:软引用有对应的实体列为SoftReference,使用软引用引用的对象只有在程序发生oom异常前才会回收,也就是说如果内存充足永远不会被回收,只有在内存不足时才会回收,很好的避免oom,非常适合做缓存。
Demo验证
[java] view
plain copy
/**
* 软引用
*/
public static void testSoftReference(){
SoftReference<Object> obj = new SoftReference<>(object);
object = null;
System.gc();
System.out.print("after system.gc---softReference = " + obj); }
由控制台的输出结果可以看到,虽然软引用引用的对象被清空,但是由于内存充足,就算是执行了gc也不会被回收。
小结一下:由以上的demo可以看到软引用和强引用在内存充足的情况下是一样的都不会被回收,只有在内存不足时软引用才会被及时回收避免oom异常,而强引用却很霸道坚决不回收。这样分析来看,使用软引用可以很好的避免oom异常,适合做一些缓存工作
[java] view
plain copy
THREE,弱引用(WeakReference)
概念介绍:弱引用对应的实体类为WeakReference,这个概念介绍起来有点儿麻烦,可以参考demo理解再总结Demo验证:
第一种情况,如果把弱引用所引用的对象置为null,但不进行gc,弱引用的get到的会是null吗?
[java] view
plain copy
public static void testWeakReference(){
WeakReference<Object> weakReference = new WeakReference<Object>(object);
WeakReference<Object> weakReferenceStr = new WeakReference<Object>(str);
object = null;
str = null;
/ System.gc();
System.out.println("after system.gc---weakReference = " + weakReference.get());
System.out.print("after system.gc---weakReferenceStr = " + weakReferenceStr.get());
}
输出结果为:
[java] view
plain copy
after system.gc---weakReference = java.lang.Object@14ae5a5
after system.gc---weakReferenceStr = strTest
Process finished with exit code 0
可以看到如果不进行gc,弱引用对象在内存充足的情况下是不会回收的,不论所引用的对象是否为null
第二种情况,不对所引用的对象置为null,直接进行gc
[java] view
plain copy
public static void testWeakReference(){
WeakReference<Object> weakReference = new WeakReference<Object>(object);
WeakReference<Object> weakReferenceStr = new WeakReference<Object>(str);
// object = null;
// str = null;
System.gc();
System.out.println("after system.gc---weakReference = " + weakReference.get());
System.out.print("after system.gc---weakReferenceStr = " + weakReferenceStr.get());
}
输出结果为
[java] view
plain copy
after system.gc---weakReference = java.lang.Object@14ae5a5
after system.gc---weakReferenceStr = strTest
Process finished with exit code 0
可以看到,此时所引用的对象不为null,所以在进行gc回收时不会回收弱引用对象。由此可以看出弱引用跟对象的生命周期有关,在对象不为null时,垃圾回收器不会回收弱引用
第三种情况
[java] view
plain copy
public static void testWeakReference(){
WeakReference<Object> weakReference = new WeakReference<Object>(object);
WeakReference<Object> weakReferenceStr = new WeakReference<Object>(str);
object = null;
str = null;
System.gc();
System.out.println("after system.gc---weakReference = " + weakReference.get());
System.out.print("after system.gc---weakReferenceStr = " + weakReferenceStr.get());
}
输出结果
[java] view
plain copy
after system.gc---weakReference = null
after system.gc---weakReferenceStr = strTest
Process finished with exit code 0
在这里说明一下str对象的定义方式
[java] view
plain copy
static String str = "strTest";
可以看到,使用new的方式构造的对象在置为null后,所对应的弱引用被回收,但是使用赋值的方式所获取的对象置为null后,所对应的弱引用没有被回收,这是为什么呢?这里暂且TODO该问题,把四大引用总结完后再研究
{add 2016-11-15
这是因为gc不清理常量池里的垃圾,所以所引用的内容不为null
}
综合以上三种情况,可以对弱引用下一个结论了,弱应用与对象的生命周期有关。在进行垃圾回收时,如果所引用的对象为null,则不论内存是否充足都会被回收,否则不会被回收。当然当内存不足时会直接被回收。
FOUR,虚引用(PhantonReference)
概念介绍,虚引用对应的实体类为PhantonReference。虚引用不论所引用的对象是不是null,不论内存空间是否充足,都会被垃圾回收器回收Demo验证
[java] view
plain copy
public static void testPhantonReference(){
ReferenceQueue<Object> referenceQueue = new ReferenceQueue<>();
PhantomReference<Object> phantomReference = new PhantomReference<>(object,referenceQueue);
PhantomReference<Object> phantomReferenceStr = new PhantomReference<>(str,referenceQueue);
// object = null;
// str = null;
System.gc();
System.out.println("after system.gc---phantomReference = " + phantomReference.get());
System.out.print("after system.gc---phantomReferenceStr = " + phantomReferenceStr.get());
}
输出结果如下
[java] view
plain copy
after system.gc---phantomReference = null
after system.gc---phantomReferenceStr = null
Process finished with exit code 0
可以看到,只要进行垃圾回收,虚引用就会被回收
总结:
对于垃圾回收器回收的顺序为
虚引用---弱引用----软引用---强引用。
多使用软引用做缓存可以很好地避免oom.
相关文章推荐
- 简单直白教你理解Java中四大引用强引用,软引用,弱引用,虚引用
- 简单理解Java GC与幽灵引用
- 简单理解Java GC与幽灵引用
- Java父类引用指向子类对象的简单理解
- 用类名做方法的返回值类型 在学习Java的初始阶段,很多同学使用基本数据类型定义变量和引用类型定义变量以及使用类名做方法的返回值类型常常不知所以。今天我以自己的解读方式和个人的理解作一个简单的解释,和
- 图解java的BI0,NIO,最简单直白的理解同步和异步IO模型
- Java参数传递造成参数值改变的情况--值传递和引用传递的初步理解
- Java String 的简单理解
- 对JAVA简单的理解
- 引用 java中abstract,interface,final,static,加深理解
- JAVA 执行顺序的简单理解
- java中关于static的简单理解
- 理解 Java 的 GC 与 幽灵引用
- 简单理解java.lang.IllegalStateException异常:简单分析和简单解决方案
- [Java学习笔记] 对象的比较(引用比较、值比较) ^_^个人的理解,请多多关照^_^
- 理解 Java 的 GC 与 幽灵引用
- java多态,如何理解父类引用指向子类对象
- 理解java传值还是传引用
- 简单理解java.lang.IllegalStateException异常:简单分析和简单解决方案
- (Java2D 学习笔记系列) (一)一个简单的图像填充实例及其分析理解