文章目录
  1. 1. 引用类型
    1. 1.1. 强引用
    2. 1.2. java.lang.ref.Reference
      1. 1.2.1. 构造函数
      2. 1.2.2. 四种状态
      3. 1.2.3. get
    3. 1.3. 软引用(soft reference)
    4. 1.4. 弱引用(weak reference)
    5. 1.5. 虚引用(phantom reference)
  2. 2. WeakHashMap.Entry
  3. 3. WeakHashMap.expungeStaleEntries
  4. 4. 实战
  5. 5. 总结
  6. 6. 参考

前面把基于特定数据结构的Map介绍完了,它们分别利用了相应数据结构的特点来实现特殊的目的,像HashMap利用哈希表的快速插入、查找实现O(1)的增删改查,TreeMap则利用了红黑树来保证key的有序性的同时,使得增删改查的时间复杂度为O(log(n))

今天要介绍的WeakHashMap并没有基于某种特殊的数据结构,它的主要目的是为了优化JVM,使JVM中的垃圾回收器(garbage collector,后面简写为 GC)更智能的回收“无用”的对象。

本文源码分析基于Oracle JDK 1.7.0_71,请知悉。

1
2
3
4
$ java -version
java version "1.7.0_71"
Java(TM) SE Runtime Environment (build 1.7.0_71-b14)
Java HotSpot(TM) 64-Bit Server VM (build 24.71-b01, mixed mode)

引用类型

WeakHashMap与其他 Map 最主要的不同之处在于其 key 是弱引用类型,其他 Map 的 key 均为强引用类型,说到这里,必须强调下:Java 中,引用有四种类型,分别为:强(strong)引用、软(soft)引用、弱(weak)引用、虚(phantom,本意为幽灵👻)引用。我相信对于 Java 初学者来说,不一定听过这几种引用类似,下面先介绍下这几种类型。

强引用

这是最常用的引用类型,在执行下面的语句时,变量 o 即为一个强引用。

1
Object o = new Object();

强引用指向的对象无论在何时,都不会被GC 清理掉。

一般来说,对于常驻类应用(比如server),随着时间的增加,所占用的内存往往会持续上升,如果程序中全部使用强引用,那么很容易造成内存泄漏,最终导致Out Of Memory (OOM),所以 Java 中提供了除强引用之外的其他三种引用,它们全部位于java.lang.ref包中,下面一一介绍。

java.lang.ref.Reference

java.lang.ref.Reference 为 软(soft)引用、弱(weak)引用、虚(phantom)引用的父类。


Reference类继承关系

下面分析下Reference的源码(其他三种引用都是其子类,区分不是很大)。

构造函数

1
2
3
4
5
6
7
8
9
10
11
//referent 为引用指向的对象
Reference(T referent) {
this(referent, null);
}
//ReferenceQueue对象,可以简单理解为一个队列
//GC 在检测到appropriate reachability changes之后,
//会把引用对象本身添加到这个queue中,便于清理引用对象本身
Reference(T referent, ReferenceQueue<? super T> queue) {
this.referent = referent;
this.queue = (queue == null) ? ReferenceQueue.NULL : queue;
}

如果我们在创建一个引用对象时,指定了ReferenceQueue,那么当引用对象指向的对象达到合适的状态(根据引用类型不同而不同)时,GC 会把引用对象本身添加到这个队列中,方便我们处理它,因为

引用对象指向的对象 GC 会自动清理,但是引用对象本身也是对象(是对象就占用一定资源),所以需要我们自己清理。

举个例子:

1
SoftReference<String> ss = new SoftReference<String>("abc" , queue);

ss 为软引用,指向abc这个对象,abc 会在一定时机被 GC 自动清理,但是ss对象本身的清理工作依赖于queue,当ss出现在queue中时,说明其指向的对象已经无效,可以放心清理ss了。

从上面的分析大家应该对Reference类有了基本的认识,但是上面也提到了,不同的引用,添加到ReferenceQueue的时机是不一样。下面介绍具体引用时再进行说明。
这里有个问题,如果创建引用对象是没有指定ReferenceQueue,引用对象会怎么样呢?这里需要了解Reference类内部的四种状态。

四种状态

每一时刻,Reference对象都处于下面四种状态中。这四种状态用Reference的成员变量queuenext(类似于单链表中的next)来标示。

1
2
ReferenceQueue<? super T> queue;
Reference next;
  • Active。新创建的引用对象都是这个状态,在 GC 检测到引用对象已经到达合适的reachability时,GC 会根据引用对象是否在创建时制定ReferenceQueue参数进行状态转移,如果指定了,那么转移到Pending,如果没指定,转移到Inactive。在这个状态中
1
2
3
//如果构造参数中没指定queue,那么queue为ReferenceQueue.NULL,否则为构造参数中传递过来的queue
queue = ReferenceQueue || ReferenceQueue.NULL
next = null
  • Pending。pending-Reference列表中的引用都是这个状态,它们等着被内部线程ReferenceHandler处理(会调用ReferenceQueue.enqueue方法)。没有注册的实例不会进入这个状态。在这个状态中
1
2
3
//构造参数参数中传递过来的queue
queue = ReferenceQueue
next = 该queue中的下一个引用,如果是该队列中的最后一个,那么为this
  • Enqueued。调用ReferenceQueue.enqueued方法后的引用处于这个状态中。没有注册的实例不会进入这个状态。在这个状态中
1
2
queue = ReferenceQueue.ENQUEUED
next = 该queue中的下一个引用,如果是该队列中的最后一个,那么为this
  • Inactive。最终状态,处于这个状态的引用对象,状态不会在改变。在这个状态中
1
2
queue = ReferenceQueue.NULL
next = this

有了这些约束,GC 只需要检测next字段就可以知道是否需要对该引用对象采取特殊处理

  • 如果nextnull,那么说明该引用为Active状态
  • 如果next不为null,那么 GC 应该按其正常逻辑处理该引用。

我自己根据Reference.ReferenceHandler.runReferenceQueue.enqueue这两个方法,画出了这四种状态的转移图,供大家参考:


Reference状态转移图

要理解这个状态 GC 到底做了什么事,需要看 JVM 的代码,我这里时间、能力都不够,就不献丑了,后面有机会再来填坑。
对于一般程序员来说,这四种状态完全可以不用管。最后简单两句话总结上面的四种状态:

  1. 如果构造函数中指定了ReferenceQueue,那么事后程序员可以通过该队列清理引用
  2. 如果构造函数中没有指定了ReferenceQueue,那么 GC 会自动清理引用

get

调用Reference.get方法可以得到该引用指向的对象,但是由于指向的对象随时可能被 GC 清理,所以即使在同一个线程中,不同时刻的调用可能返回不一样的值。

软引用(soft reference)

软引用“保存”对象的能力稍逊于强引用,但是高于弱引用,一般用来实现memory-sensitive caches。

软引用指向的对象会在程序即将触发OOM时被GC 清理掉,之后,引用对象会被放到ReferenceQueue中。

弱引用(weak reference)

软引用“保存”对象的能力稍逊于弱引用,但是高于虚引用,一般用来实现canonicalizing mapping,也就是本文要讲的WeakHashMap😊。

当弱引用指向的对象只能通过弱引用(没有强引用或弱引用)访问时,GC会清理掉该对象,之后,引用对象会被放到ReferenceQueue中。

虚引用(phantom reference)

虚引用是“保存”对象能力最弱的引用,一般用来实现scheduling pre-mortem cleanup actions in a more flexible way than is possible with the Java finalization mechanism

调用虚引用的get方法,总会返回null,与软引用和弱引用不同的是,虚引用被enqueued时,GC 并不会自动清理虚引用指向的对象,只有当指向该对象的所有虚引用全部被清理(enqueued后)后或其本身不可达时,该对象才会被清理。

WeakHashMap.Entry

上面介绍了很多引用的知识点,其实WeakHashMap本身没什么好说的,只要是把引用的作用与使用场景搞清楚了,再来分析基于这些引用的对象就会很简单了。
WeakHashMapHashMap的签名与构造函数一样,这里就不介绍了,这里重点介绍下Entry这个内部对象,因为其保存具体key-value对,所以把它弄清楚了,其他的就问题不大了。

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
/**
* The entries in this hash table extend WeakReference, using its main ref
* field as the key.
*/
private static class Entry<K,V> extends WeakReference<Object> implements Map.Entry<K,V> {
V value;
int hash;
Entry<K,V> next;
/**
* Creates new entry.
*/
Entry(Object key, V value,
ReferenceQueue<Object> queue,
int hash, Entry<K,V> next) {
//这里把key传给了父类WeakReference,说明key为弱引用(没有显式的 this.key = key)
//所有如果key只有通过弱引用访问时,key会被 GC 清理掉
//同时该key所代表的Entry会进入queue中,等待被处理
//还可以看到value为强引用(有显式的 this.value = value ),但这并不影响
//后面可以看到WeakHashMap.expungeStaleEntries方法是如何清理value的
super(key, queue);
this.value = value;
this.hash = hash;
this.next = next;
}
@SuppressWarnings("unchecked")
//在获取key时需要unmaskNull,因为对于null的key,是用WeakHashMap的内部成员属性来表示的
public K getKey() {
return (K) WeakHashMap.unmaskNull(get());
}
public V getValue() {
return value;
}
public V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
public boolean equals(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
K k1 = getKey();
Object k2 = e.getKey();
if (k1 == k2 || (k1 != null && k1.equals(k2))) {
V v1 = getValue();
Object v2 = e.getValue();
if (v1 == v2 || (v1 != null && v1.equals(v2)))
return true;
}
return false;
}
public int hashCode() {
K k = getKey();
V v = getValue();
return ((k==null ? 0 : k.hashCode()) ^
(v==null ? 0 : v.hashCode()));
}
public String toString() {
return getKey() + "=" + getValue();
}
}

WeakHashMap.expungeStaleEntries

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
30
31
32
33
34
35
36
37
38
39
40
/**
* Reference queue for cleared WeakEntries
*/
// 所有Entry在构造时都传入该queue
private final ReferenceQueue<Object> queue = new ReferenceQueue<>();
/**
* Expunges stale entries from the table.
*/
private void expungeStaleEntries() {
for (Object x; (x = queue.poll()) != null; ) {
synchronized (queue) {
// e 为要清理的对象
@SuppressWarnings("unchecked")
Entry<K,V> e = (Entry<K,V>) x;
int i = indexFor(e.hash, table.length);
Entry<K,V> prev = table[i];
Entry<K,V> p = prev;
// while 循环遍历冲突链
while (p != null) {
Entry<K,V> next = p.next;
if (p == e) {
if (prev == e)
table[i] = next;
else
prev.next = next;
// Must not null out e.next;
// stale entries may be in use by a HashIterator
// 可以看到这里把value赋值为null,来帮助 GC 回收强引用的value
e.value = null; // Help GC
size--;
break;
}
prev = p;
p = next;
}
}
}
}

知道了expungeStaleEntries方法的作用,下面看看它是何时被调用的


expungeStaleEntries调用链

可以看到,在对WeakHashMap进行增删改查时,都调用了expungeStaleEntries方法。

实战

上面说了,下面来个具体的例子帮助大家消化

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
30
31
32
33
34
35
36
37
38
39
40
41
42
import java.util.WeakHashMap;
class KeyHolder {
@Override
protected void finalize() throws Throwable {
System.out.println("I am over from key");
super.finalize();
}
}
class ValueHolder {
@Override
protected void finalize() throws Throwable {
System.out.println("I am over from value");
super.finalize();
}
}
public class RefTest {
public static void main(String[] args) {
WeakHashMap<KeyHolder, ValueHolder> weakMap = new WeakHashMap<KeyHolder, ValueHolder>();
KeyHolder kh = new KeyHolder();
ValueHolder vh = new ValueHolder();
weakMap.put(kh, vh);
while (true) {
for (KeyHolder key : weakMap.keySet()) {
System.out.println(key + " : " + weakMap.get(key));
}
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("here...");
//这里把kh设为null,这样一来就只有弱引用指向kh指向的对象
kh = null;
System.gc();
}
}
}

输出

1
2
3
4
5
6
7
8
9
KeyHolder@a15670a : ValueHolder@20e1ed5b
here...
I am over from key //输出这句话说明,该key对应的Entry已经被 GC 清理
here...
here...
here...
...
...
...

总结

说实话,之前我是没怎么了解过引用,更是没有用过WeakHashMap这个类,这次算是把这个坑给填上了。引用的使用场景应该是在常驻类或消耗内存较大应用中才用得上,我自己确实没怎么经历过这种类型的项目,只能现在打好基础,以后有机会在尝试。

其实关于引用,本文重点介绍了弱引用的使用场景,其他的没怎么介绍,感兴趣的可以阅读参考中给出的链接。😊

参考


KeepWritingCodes 微信公众号

本博客使用 disqus 评论系统,但不幸被墙,不会翻墙的小伙伴可以通过上面的公众号与我交流。希望我们的交流能给你我带来些许启发。

PS: 微信公众号,头条,掘金等平台均有我文章的分享,但我的文章会随着我理解的加深不定期更新,建议大家最好去我的博客 liujiacai.net 阅读最新版。

文章目录
  1. 1. 引用类型
    1. 1.1. 强引用
    2. 1.2. java.lang.ref.Reference
      1. 1.2.1. 构造函数
      2. 1.2.2. 四种状态
      3. 1.2.3. get
    3. 1.3. 软引用(soft reference)
    4. 1.4. 弱引用(weak reference)
    5. 1.5. 虚引用(phantom reference)
  2. 2. WeakHashMap.Entry
  3. 3. WeakHashMap.expungeStaleEntries
  4. 4. 实战
  5. 5. 总结
  6. 6. 参考