强引用、软引用、弱引用、幻象引用

体现在对象不同的可达性(reachable)状态和对垃圾收集的影响

强引用 StrongReference

常见的引用,只要还有强引用指向一个对象,垃圾收集器不会碰这种对象。对于一个普通的对象,如果没有其他的引用关系,只要超过了引用的作用域或者显式地将相应(强)引用赋值为 null,就是可以被垃圾回收器进行回收

项目中new出来的全是强引用

软引用 SoftReference

相对强引用弱化一些的引用,只有当JVM 认为内存不足时,才会去试图回收软引用指向的对象。JVM 会确保在抛出 OutOfMemoryError 之前,清理软引用指向的对象。软引用通常用来实现内存敏感的缓存,如果还有空闲内存,就可以暂时保留缓存,当内存不足时清理掉,这样就保证了使用缓存的同时,不会耗尽内存,软引用可以和一个引用队列(ReferenceQueue)联合使用,如果软引用所引用的对象被垃圾回收器回收,Java虚拟机就会把这个软引用加入到与之关联的引用队列中。后续,我们可以调用ReferenceQueue的poll()方法来检查是否有它所关心的对象被回收。如果队列为空,将返回一个null,否则该方法返回队列中前面的一个Reference对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/*
* 虚拟机参数配置
* -Xms256m
* -Xmx1024m
*/
public class SoftReferenceSample {
public static void main(String[] args){

/*软引用对象中指向了一个长度为300000000个元素的整形数组*/
SoftReference<int[]> softReference =
new SoftReference<int[]>(new int[300000000]);

/*主动调用一次gc,由于此时JVM的内存够用,此时softReference引用的对象未被回收*/
System.gc();
System.out.println(softReference.get());

/*消耗内存,会导致一次自动的gc,此时JVM的内存不够用
*就回收softReference对象中指向的数组对象*/
int[] strongReference = new int[100000000];

System.out.println(softReference.get());
}
}

Android中常用于图片缓存框架,“内存缓存”中的图片是以这种引用来保存,使得JVM在发生OOM之前,可以回收这部分缓存

弱引用 WeakReference

弱引用通过WeakReference类实现。 弱引用的生命周期比软引用短。在垃圾回收器线程扫描它所管辖的内存区域的过程中,一旦发现了具有弱引用的对象,不管当前内存空间足够与否,都会回收它的内存。由于垃圾回收器是一个优先级很低的线程,因此不一定会很快回收弱引用的对象。弱引用可以和一个引用队列(ReferenceQueue)联合使用,如果弱引用所引用的对象被垃圾回收,Java虚拟机就会把这个弱引用加入到与之关联的引用队列中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class WeakReferenceSample {
public static void main(String[] args){

/*若引用对象中指向了一个长度为1000个元素的整形数组*/
WeakReference<String[]> weakReference =
new WeakReference<String[]>(new String[1000]);

/*未执行gc,目前仅被弱引用指向的对象还未被回收,所以结果不是null*/
System.out.println(weakReference.get());

/*执行一次gc,即使目前JVM的内存够用,但还是回收仅被弱引用指向的对象*/
System.gc();
System.out.println(weakReference.get());
}
}

就像HashMap,假设我们的value存的是一个对象,当我想把这个对象设置为null时,还需要在hashmap中remove才算真正地把引用都删除,因为hashmap中的key引用着这个对象
这时候可以使用弱引用来解决,而不用去手动使用HashMap删除

1
2
Product productA = new Product(...);
WeakReference<Product> weakProductA = new WeakReference<>(productA);

幻象引用

对于幻象引用,(虚引用),你不能通过它访问对象。幻象引用仅仅是提供了一种确保对象被finalize以后,做某些事情的机制。虚引用只是用来得知对象是否被GC。如果一个对象仅持有虚引用,那么它就和没有任何引用一样,在任何时候都可能被垃圾回收器回收。虚引用必须和引用队列(ReferenceQueue)联合使用。当垃圾回收器准备回收一个对象时,如果发现它还有虚引用,就会在回收对象的内存之前,把这个虚引用加入到与
之关联的引用队列中

看到过一个非常有意思的比喻

  • 强引用就像大老婆,关系很稳固
  • 软引用就像二老婆,随时有失宠的可能,但也有转正的可能
  • 弱引用就像情人,关系不稳定,可能跟别人跑了
  • 幻像引用就是梦中情人,只在梦里出现过

对象可达性状态流转分析

  • 强可达(Strongly Reachable),就是当一个对象可以有一个或多个线程可以不通过各种引用访问到的情况。比如,我们新创建一个对象,那么创建它的线程对它就是强可达
  • 软可达(Softly Reachable),就是当我们只能通过软引用才能访问到对象的状态
  • 弱可达(Weakly Reachable),类似前面提到的,就是无法通过强引用或者软引用访问,只能通过弱引用访问时的状态。这是十分临近 finalize 状态的时机,当弱引用被清除的时候,就符合 finalize 的条件了
  • 幻象可达(Phantom Reachable),上面流程图已经很直观了,就是没有强、软、弱引用关联,并且 finalize 过了,只有幻象引用指向这个对象的时候
  • 当然,还有一个最后的状态,就是不可达(unreachable),意味着对象可以被清除了

判断对象可达性,是 JVM 垃圾收集器决定如何处理对象的一部分考虑

除了幻象引用(因为 get 永远返回 null),如果对象还没有被销毁,都可以通过 get 方法获取原有对象。这意味着,利用软引用和弱引用,我们可以将访问到的对象,重新指向强引用,也就是人为的改变了对象的可达性状态,也就是上图中双箭头的表示

在Android开发中,很容易出现的内存泄漏,会出现在这个地方.假设我们把引用给了一个 static 变量,对象就可能就没有机会变回类似弱引用的可达性状态了,就会产生内存泄漏

引用队列

ReferenceQueue

当gc(垃圾回收线程)准备回收一个对象时,如果发现它还仅有软引用(或弱引用,或虚引用)指向它,就会在回收该对象之前,把这个软引用(或弱引用,或虚引用)加入到与之关联的引用队列(ReferenceQueue)中。如果一个软引用(或弱引用,或虚引用)对象本身在引用队列中,就说明该引用对象所指向的对象被回收了

当软引用(或弱引用,或虚引用)对象所指向的对象被回收了,那么这个引用对象本身就没有价值了,如果程序中存在大量的这类对象(注意,我们创建的软引用、弱引用、虚引用对象本身是个强引用,不会自动被gc回收),就会浪费内存。因此我们这就可以手动回收位于引用队列中的引用对象本身

ReferenceQueue 回收率并不高,就不做代码演示了

WeakHashMap

和前面讲到的hashMap类似,WeakHahsMap 的实现原理简单来说就是HashMap里面的条目 Entry继承了 WeakReference,那么当 Entry 的 key 不再被使用(即,引用对象不可达)且被 GC 后,那么该 Entry 就会进入到 ReferenceQueue 中.

当我们调用WeakHashMap 的get和put方法会有一个副作用,即清除无效key对应的Entry。这个过程就和上面的代码很类似了,首先会从引用队列中取出一个Entry对象,然后在HashMap中查找这个Entry对象的位置,最后把这个 Entry 从 HashMap中删除,这时key和value对象都被回收了。重复这个过程直到队列为空.

WeakHashMap是线程安全的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public class WeakHashMapSample {
public static void main(String[] args){

WeakHashMap<String, byte[]> whm = new WeakHashMap<String, byte[]>();
String s1 = new String("s1");
String s2 = new String("s2");
String s3 = new String("s3");

whm.put(s1, new byte[100]);
whm.put(s2, new byte[100]);
whm.put(s3, new byte[100]);

s2 = null;
s3 = null;

/*此时可能还未执行gc,所以可能还可以通过仅有弱引用的key找到value*/
System.out.println(whm.get("s1"));
System.out.println(whm.get("s2"));
System.out.println(whm.get("s3"));

System.out.println("-------------------");

/*执行gc,导致仅有弱引用的key对应的entry(包括value)全部被回收*/
System.gc();
System.out.println(whm.get("s1"));
System.out.println(whm.get("s2"));
System.out.println(whm.get("s3"));
}
}