Java中的四种引用类型 Strong, Soft, Weak And Phantom
2017-06-04 14:18
701 查看
前言
总所周知, java不同于c/c++,它不需要程序员自已来管理内存(分配,释放内存),java 会自己来管理内存,比如销毁某些不再被使用的对象。这些操作都是在一个后台线程默默进行(Garbage Collector Thread),也就是垃圾收集器线程,根据jvm实现的策略来释放对象内存。但是程序编写者却无法控制这个后台线程,无法让它在你想要的时候开始释放内存,销毁对象,按照你的规定来销毁那些对象,释放内存,这些都是都jvm自己控制的。但是随着 java.lang.ref这个包下的类的引进,程序员拥有了一点点控制你创建的对象何时释放,销毁的权利,当然只是一点点。那接下来就来看看这些类和java中的四种引用类型有何对应关系。先来看看这四种引用类型,因为jvm在进行垃圾收集的时候,需要判断哪些对象需要销毁,这时就与这几种引用类型相关。
以下是这几种引用类型:
接下来看看下面这个简单的例子:
也可以画个简单的图理解一下:
重点: 被弱引用指向的对象不会被垃圾收集器收集(即使该对象没有强引用指向它),除非jvm使用内存不够了,才会对这类对象进行销毁,释放内存。举个简单的例子:
有兴趣可以去看看Reference的源码。
现在是不是想到了软引用的一个使用场景,它相比与强引用可以避免OOM。
现在可以简单的测试下 当jvm内存不足的情况下,软引用的回收情况。
为了更快的看到结果,我限制了jvm的最大堆内存 -Xmx100m 为100m
运行 输出结果:
可以看到当jvm内存耗尽的时候,会将弱引用的对象进行回收 上面的例子的10m,且刚好还可以分配两次 5m一次 ,输出了两次null也证明了这一点
当然我们在创建软引用时,还可以传入ReferenceQueue,这个队列有啥用呢? 当jvm回收某个软引用对象之后会将该SoftReference对象(例子中的softRef对象)添加进这个队列,因此我们就知道这个对象啥时候被回收了,可以做一些我们想做的操作。
还是举个简单的例子
运行 输出结果:
来个简单的例子:
运行 输出结果:
从结果中可以清晰的看到弱引用对象并不需要在jvm耗尽内存的情况下才进行回收, 是可以随时回收的。
来个例子看看:
运行 结果:
总所周知, java不同于c/c++,它不需要程序员自已来管理内存(分配,释放内存),java 会自己来管理内存,比如销毁某些不再被使用的对象。这些操作都是在一个后台线程默默进行(Garbage Collector Thread),也就是垃圾收集器线程,根据jvm实现的策略来释放对象内存。但是程序编写者却无法控制这个后台线程,无法让它在你想要的时候开始释放内存,销毁对象,按照你的规定来销毁那些对象,释放内存,这些都是都jvm自己控制的。但是随着 java.lang.ref这个包下的类的引进,程序员拥有了一点点控制你创建的对象何时释放,销毁的权利,当然只是一点点。那接下来就来看看这些类和java中的四种引用类型有何对应关系。先来看看这四种引用类型,因为jvm在进行垃圾收集的时候,需要判断哪些对象需要销毁,这时就与这几种引用类型相关。
以下是这几种引用类型:
1. 强引用(Strong References)
强引用类型是我们平时写代码的时候最常用的引用,而大部分人往往都会忽略这个概念,都成一种理所当然的事情了。接下来看看下面这个简单的例子:
public class Main { public static void main(String[] args) { //创建一个对象,new出来的对象都是分配在java堆中的 Sample sample = new Sample(); //sample这个引用就是强引用 sample = null; //将这个引用指向空指针, //那么上面那个刚new来的对象就没用任何其它有效的引用指向它了 //也就说该对象对于垃圾收集器是符合条件的 //因此在接下来某个时间点 GC进行收集动作的时候, 该对象将会被销毁,内存被释放 } } class Sample { }
也可以画个简单的图理解一下:
2. 软引用(Soft References)
软引用在java.lang.ref包中有与之对应的类java.lang.ref.SoftReference。重点: 被弱引用指向的对象不会被垃圾收集器收集(即使该对象没有强引用指向它),除非jvm使用内存不够了,才会对这类对象进行销毁,释放内存。举个简单的例子:
public class Main { public static void main(String[] args) { //创建一个对象,new出来的对象都是分配在java堆中的 Sample sample = new Sample(); //sample这个引用就是强引用 //创建一个软引用指向这个对象 那么此时就有两个引用指向Sample对象 SoftReference<Sample> softRef = new SoftReference<Sample>(sample); //将强引用指向空指针 那么此时只有一个软引用指向Sample对象 //注意:softRef这个引用也是强引用,它是指向SoftReference这个对象的 //那么这个软引用在哪呢? 可以跟一下java.lang.Reference的源码 //private T referent; 这个才是软引用, 只被jvm使用 sample = null; //可以重新获得Sample对象,并用一个强引用指向它 sample = softRef.get(); } } class Sample { }
有兴趣可以去看看Reference的源码。
现在是不是想到了软引用的一个使用场景,它相比与强引用可以避免OOM。
现在可以简单的测试下 当jvm内存不足的情况下,软引用的回收情况。
为了更快的看到结果,我限制了jvm的最大堆内存 -Xmx100m 为100m
public class Main { private static final List<Object> TEST_DATA = new LinkedList<>(); public static void main(String[] args) throws InterruptedException { //创建一个对象,new出来的对象都是分配在java堆中的 Sample sample = new Sample(); //sample这个引用就是强引用 //创建一个软引用指向这个对象 那么此时就有两个引用指向Sample对象 SoftReference<Sample> softRef = new SoftReference<Sample>(sample); //将强引用指向空指针 那么此时只有一个软引用指向Sample对象 //注意:softRef这个引用也是强引用,它是指向SoftReference这个对象的 //那么这个软引用在哪呢? 可以跟一下java.lang.Reference的源码 //private T referent; 这个才是软引用, 只被jvm使用 sample = null; //可以重新获得Sample对象,并用一个强引用指向它 //sample = softRef.get(); new Thread(){ @Override public void run() { while (true) { System.out.println(softRef.get()); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } TEST_DATA.add(new byte[1024 * 1024 * 5]); } } }.start(); Thread.currentThread().join(); } } class Sample { private final byte[] data; public Sample() { data = new byte[1024 * 1024 * 10]; } }
运行 输出结果:
example.Sample@3f580216 example.Sample@3f580216 example.Sample@3f580216 example.Sample@3f580216 example.Sample@3f580216 example.Sample@3f580216 example.Sample@3f580216 null null Exception in thread "Thread-0" java.lang.OutOfMemoryError: Java heap space at example.Main$1.run(Main.java:42)
可以看到当jvm内存耗尽的时候,会将弱引用的对象进行回收 上面的例子的10m,且刚好还可以分配两次 5m一次 ,输出了两次null也证明了这一点
当然我们在创建软引用时,还可以传入ReferenceQueue,这个队列有啥用呢? 当jvm回收某个软引用对象之后会将该SoftReference对象(例子中的softRef对象)添加进这个队列,因此我们就知道这个对象啥时候被回收了,可以做一些我们想做的操作。
public SoftReference(T referent, ReferenceQueue<? super T> q) { super(referent, q); this.timestamp = clock; } Reference(T referent, ReferenceQueue<? super T> queue) { this.referent = referent; this.queue = (queue == null) ? ReferenceQueue.NULL : queue; }
还是举个简单的例子
public class Main { private static final List<Object> TEST_DATA = new LinkedList<>(); private static final ReferenceQueue<Sample> QUEUE = new ReferenceQueue<>(); public static void main(String[] args) { //创建一个对象,new出来的对象都是分配在java堆中的 Sample sample = new Sample(); //sample这个引用就是强引用 //创建一个软引用指向这个对象 那么此时就有两个引用指向Sample对象 SoftReference<Sample> softRef = new SoftReference<Sample>(sample, QUEUE); //将强引用指向空指针 那么此时只有一个软引用指向Sample对象 //注意:softRef这个引用也是强引用,它是指向SoftReference这个对象的 //那么这个软引用在哪呢? 可以跟一下java.lang.Reference的源码 //private T referent; 这个才是软引用, 只被jvm使用 sample = null; //可以重新获得Sample对象,并用一个强引用指向它 //sample = softRef.get(); new Thread(){ @Override public void run() { while (true) { System.out.println(softRef.get()); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); Thread.currentThread().interrupt(); } TEST_DATA.add(new byte[1024 * 1024 * 5]); } } }.start(); new Thread(){ @Override public void run() { while (true) { Reference<? extends Sample> poll = QUEUE.poll(); if (poll != null) { System.out.println("--- 软引用对象被jvm回收了 ---- " + poll); System.out.println("--- 回收对象 ---- " + poll.get()); } } } }.start(); try { Thread.currentThread().join(); } catch (InterruptedException e) { System.exit(1); } } } class Sample { private final byte[] data; public Sample() { data = new byte[1024 * 1024 * 10]; } }
运行 输出结果:
example.Sample@2a3c142c example.Sample@2a3c142c example.Sample@2a3c142c example.Sample@2a3c142c example.Sample@2a3c142c example.Sample@2a3c142c example.Sample@2a3c142c --- 软引用对象被jvm回收了 ---- java.lang.ref.SoftReference@306d3b64 null --- 回收对象 ---- null null Exception in thread "Thread-0" java.lang.OutOfMemoryError: Java heap space at example.Main$1.run(Main.java:47)
3. 弱引用(Weak References)
弱引用会被jvm忽略,也就说在GC进行垃圾收集的时候,如果一个对象只有弱引用指向它,那么和没有引用指向它是一样的效果,jvm都会对它就行果断的销毁,释放内存。其实这个特性是很有用的,jdk也提供了java.util.WeakHashMap这么一个key为弱引用的Map。比如某个资源对象你要释放(比如 db connection), 但是如果被其它map作为key强引用了,就无法释放,被jvm收集。来个简单的例子:
public class Main { private static final List<Object> TEST_DATA = new LinkedList<>(); private static final ReferenceQueue<Sample> QUEUE = new ReferenceQueue<>(); public static void main(String[] args) { //创建一个对象,new出来的对象都是分配在java堆中的 Sample sample = new Sample(); //sample这个引用就是强引用 //创建一个弱引用指向这个对象 那么此时就有两个引用指向Sample对象 //SoftReference<Sample> softRef = new SoftReference<Sample>(sample, QUEUE); WeakReference<Sample> weakRef = new WeakReference<Sample>(sample, QUEUE); //将强引用指向空指针 那么此时只有一个弱引用指向Sample对象 //注意:softRef这个引用也是强引用,它是指向SoftReference这个对象的 //那么这个弱引用在哪呢? 可以跟一下java.lang.Reference的源码 //private T referent; 这个才是弱引用, 只被jvm使用 sample = null; //可以重新获得Sample对象,并用一个强引用指向它 //sample = softRef.get(); new Thread(){ @Override public void run() { while (true) { System.out.println(weakRef.get()); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); Thread.currentThread().interrupt(); } TEST_DATA.add(new byte[1024 * 1024 * 5]); } } }.start(); new Thread(){ @Override public void run() { while (true) { Reference<? extends Sample> poll = QUEUE.poll(); if (poll != null) { System.out.println("--- 弱引用对象被jvm回收了 ---- " + poll); System.out.println("--- 回收对象 ---- " + poll.get()); } } } }.start(); try { Thread.currentThread().join(); } catch (InterruptedException e) { System.exit(1); } } } class Sample { private final byte[] data; public Sample() { data = new byte[1024 * 1024 * 10]; } }
运行 输出结果:
example.Sample@234c0f50 example.Sample@234c0f50 --- 弱引用对象被jvm回收了 ---- java.lang.ref.WeakReference@16fea746 --- 回收对象 ---- null null null null null null null null Exception in thread "Thread-0" java.lang.OutOfMemoryError: Java heap space at example.Main$1.run(Main.java:47)
从结果中可以清晰的看到弱引用对象并不需要在jvm耗尽内存的情况下才进行回收, 是可以随时回收的。
4. 虚幻引用(Phantom References)
虚幻应用和弱引用的回收机制差不多,都是可以被随时回收的。但是不同的地方是,它的构造方法必须强制传入ReferenceQueue,因为在jvm回收前(重点: 对,就是回收前,软引用和弱引用都是回收后),会将PhantomReference对象加入ReferenceQueue中; 还有一点就是PhantomReference.get()方法永远返回空,不管对象有没有被回收。源码: java.lang.ref.PhantomReference /** * Returns this reference object's referent. Because the referent of a * phantom reference is always inaccessible, this method always returns * <code>null</code>. * * @return <code>null</code> */ public T get() { return null; }
来个例子看看:
public class Main { private static final List<Object> TEST_DATA = new LinkedList<>(); private static final ReferenceQueue<Sample> QUEUE = new ReferenceQueue<>(); public static void main(String[] args) { Sample sample = new Sample(); PhantomReference<Sample> phantomRef = new PhantomReference<>(sample, QUEUE); sample = null; new Thread(){ @Override public void run() { while (true) { System.out.println(phantomRef.get()); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); Thread.currentThread().interrupt(); } TEST_DATA.add(new byte[1024 * 1024 * 5]); } } }.start(); new Thread(){ @Override public void run() { while (true) { Reference<? extends Sample> poll = QUEUE.poll(); if (poll != null) { System.out.println("--- 虚幻引用对象被jvm回收了 ---- " + poll); System.out.println(poll.isEnqueued()); System.out.println("--- 回收对象 ---- " + poll.get()); } } } }.start(); try { Thread.currentThread().join(); } catch (InterruptedException e) { System.exit(1); } } } class Sample { private final byte[] data; public Sample() { data = new byte[1024 * 1024 * 10]; } }
运行 结果:
null null --- 虚幻引用对象被jvm回收了 ---- java.lang.ref.PhantomReference@40788638 false --- 回收对象 ---- null null null null null
相关文章推荐
- Java中的四种引用类型 Strong, Soft, Weak And Phantom
- java基础学习(8)4种引用类型简析StrongReference、 SoftReference、 WeakReference 、PhantomReference
- Java之引用类型分析(SoftReference/WeakReference/PhantomReference)
- Java的引用StrongReference、 SoftReference、 WeakReference 、PhantomReference
- Java strong、soft、weak以及phantom引用
- java持有引用(Strong/soft/weak/phantom Reference)
- Java的引用StrongReference、 SoftReference、 WeakReference 、PhantomReference
- Java的引用StrongReference、 SoftReference、 WeakReference 、PhantomReference
- Java引用总结--StrongReference、SoftReference、WeakReference、PhantomReference
- Java引用总结--StrongReference、SoftReference、WeakReference、PhantomReference
- Java引用总结--StrongReference、SoftReference、WeakReference、PhantomReference
- Java中三个引用类SoftReference 、 WeakReference 和 PhantomReference的区别
- [置顶] (柯昌合)内存优化之"软引用" Strong, Soft, Weak, Phantom Reference(柯昌合)
- Java中三个引用类SoftReference 、 WeakReference 和 PhantomReference的区别
- Java引用总结--StrongReference、SoftReference、WeakReference、PhantomReference
- Java中三个引用类SoftReference 、 WeakReference 和 PhantomReference的区别
- java强引用(StrongReference),软引用(SoftReference),弱引用(WeakReference),PhantomRefrence(虚引用)的区别
- Java引用对象SoftReference WeakReference PhantomReference
- 强(strong)、软(soft)、弱(weak)、虚(phantom)引用
- Java中三个引用类SoftReference 、 WeakReference 和 PhantomReference的区别