ITPub博客
首页 博客 专栏 学院 社区 IT新媒体评选
发博

首页 > IT职业 > IT生活 > Java WeakHashMap 源码解析

Java WeakHashMap 源码解析

IT生活 作者：zhjjj 时间：2021-09-09 09:29:14 0 删除 编辑

原文链接

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

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

引用类型

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

强引用

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

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的源码（其他三种引用都是其子类，区分不是很大）。


构造函数

//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 会自动清理，但是引用对象本身也是对象（是对象就占用一定资源），所以需要我们自己清理。

举个例子：

SoftReference ss = new SoftReference("abc" , queue);

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

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

四种状态

每一时刻，Reference对象都处于下面四种状态中。这四种状态用Reference的成员变量queue与next（类似于单链表中的next）来标示。

ReferenceQueue super T> queue;
Reference next;

Active。新创建的引用对象都是这个状态，在 GC 检测到引用对象已经到达合适的reachability时，GC 会根据引用对象是否在创建时制定ReferenceQueue参数进行状态转移，如果指定了，那么转移到Pending，如果没指定，转移到Inactive。在这个状态中

//如果构造参数中没指定queue，那么queue为ReferenceQueue.NULL，否则为构造参数中传递过来的queuequeue = ReferenceQueue || ReferenceQueue.NULLnext = null

Pending。pending-Reference列表中的引用都是这个状态，它们等着被内部线程ReferenceHandler处理（会调用ReferenceQueue.enqueue方法）。没有注册的实例不会进入这个状态。在这个状态中

//构造参数参数中传递过来的queuequeue = ReferenceQueue
next = 该queue中的下一个引用，如果是该队列中的最后一个，那么为this

Enqueued。调用ReferenceQueue.enqueued方法后的引用处于这个状态中。没有注册的实例不会进入这个状态。在这个状态中

queue = ReferenceQueue.ENQUEUEDnext = 该queue中的下一个引用，如果是该队列中的最后一个，那么为this

Inactive。最终状态，处于这个状态的引用对象，状态不会在改变。在这个状态中

queue = ReferenceQueue.NULLnext = this

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

  • 如果next为null，那么说明该引用为Active状态

  • 如果next不为null，那么 GC 应该按其正常逻辑处理该引用。

我自己根据Reference.ReferenceHandler.run与ReferenceQueue.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本身没什么好说的，只要是把引用的作用与使用场景搞清楚了，再来分析基于这些引用的对象就会很简单了。
WeakHashMap与HashMap的签名与构造函数一样，这里就不介绍了，这里重点介绍下Entry这个内部对象，因为其保存具体key-value对，所以把它弄清楚了，其他的就问题不大了。

/**
  * The entries in this hash table extend WeakReference, using its main ref
  * field as the key.
  */
 private static class Entry extends WeakReference implements Map.Entry {
     V value;     int hash;
     Entry next;     /**
      * Creates new entry.
      */
     Entry(Object key, V value,
           ReferenceQueue queue,           int hash, Entry 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

/**
 * Reference queue for cleared WeakEntries
 */// 所有Entry在构造时都传入该queueprivate final ReferenceQueue 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 e = (Entry) x;            int i = indexFor(e.hash, table.length);
            Entry prev = table[i];
            Entry p = prev;            // while 循环遍历冲突链
            while (p != null) {
                Entry 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方法。


实战

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

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 weakMap = new WeakHashMap();
        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();
        }
    }
}

输出

KeyHolder@a15670a : ValueHolder@20e1ed5b
here...
I am over from key   //输出这句话说明，该key对应的Entry已经被 GC 清理here...
here...
here...
...
...
...

总结

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

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


来自 “ ITPUB博客 ” ，链接：https://blog.itpub.net/717/viewspace-2810138/ ，如需转载，请注明出处，否则将追究法律责任。

0
0
上一篇： 记一次真实的网站被DDOS攻击经历
下一篇： Android调试利器Pandora了解下哇-Part2
请登录后发表评论 登录
全部评论
zhjjj

注册时间：2019-04-12

  • 博文量
    231
  • 访问量
    1891

最新文章

支持我们 作者招募 用户协议 FAQ Contact Us

北京盛拓优讯信息技术有限公司. 版权所有  京ICP备16024965号-8 北京市公安局海淀分局网监中心备案编号：11010802021510 niuxiaotong@pcpop.com 17352615567 未成年人举报专区

广播电视节目制作经营许可证(京) 字第1234号 中国互联网协会会员

违法和不良信息举报电话:18101376593