WeakHashMap源码解析

最新推荐文章于 2024-04-23 13:01:43 发布
最新推荐文章于 2024-04-23 13:01:43 发布
阅读量386 收藏
点赞数
分类专栏： Java集合框架源码 文章标签： java 数据结构 jvm 缓存 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53407527/article/details/128251080
版权

WeakHashMap源码解析

简介

WeakHashMap 是一种 弱引用 map，内部的 key 会存储为弱引用，当 jvm gc 的时候，如果这些 key 没有强引用存在的话，会被 gc 回收掉，下一次当我们操作 map 的时候会把对应的 Entry 整个删除掉，基于这种特性，WeakHashMap 特别适用于 缓存 处理。

继承体系

image-20221204180736143

可见，WeakHashMap 没有实现 Clone 和 Serializable 接口，所以不具有克隆和序列化的特性。

存储结构

WeakHashMap 因为 gc 的时候会把没有强引用的 key 回收掉，所以注定了它里面的元素不会太多，因此也就不需要像 HashMap 那样元素多的时候转化为红黑树来处理了。

因此，WeakHashMap 的存储结构只有 (数组 + 链表) 。

源码解析

属性

    /*
     * 默认初始容量为16
     */
    private static final int DEFAULT_INITIAL_CAPACITY = 16;

    /*
     * 最大容量为2的30次方
     */
    private static final int MAXIMUM_CAPACITY = 1 << 30;

    /*
     * 默认装载因子
     */
    private static final float DEFAULT_LOAD_FACTOR = 0.75f;

    /*
     * 桶
     */
    Entry<K,V>[] table;

    /*
     * 元素个数
     */
    private int size;

    /*
     * 扩容门槛，等于capacity * loadFactor
     */
    private int threshold;

    /*
     * 装载因子
     */
    private final float loadFactor;

    /*
     * 引用队列，当弱键失效的时候会把Entry添加到这个队列中
     */
    private final ReferenceQueue<Object> queue = new ReferenceQueue<>();

（1）容量

  • 容量为数组的长度，亦即桶的个数，默认为 16，最大为 2 的 30 次方，当容量达到 64 时才可以树化。

（2）装载因子

  • 装载因子用来计算容量达到多少时才进行扩容，默认装载因子为 0.75。

（3）引用队列

  • 当弱键失效的时候会把 Entry 添加到这个队列中，当下次访问 map 的时候会把失效的 Entry 清除掉。

内部类Entry

WeakHashMap 内部的存储节点，没有 key 属性。

    // 继承与弱引用类WeakReference
	private static class Entry<K,V> extends WeakReference<Object> implements Map.Entry<K,V> {
        // 可以发现没有key，因为key是作为弱引用存到Reference类中
        V value;
        final int hash;
        Entry<K,V> next;

        Entry(Object key, V value,
              ReferenceQueue<Object> queue,
              int hash, Entry<K,V> next) {
            // 调用WeakReference的构造方法初始化key和引用队列
            super(key, queue);
            this.value = value;
            this.hash  = hash;
            this.next  = next;
        }
    }

    public class WeakReference<T> extends Reference<T> {
        public WeakReference(T referent, ReferenceQueue<? super T> q) {
            // 调用Reference的构造方法初始化key和引用队列
            super(referent, q);
        }
    }

    public abstract class Reference<T> {
        // 实际存储key的地方
        private T referent;         /* Treated specially by GC */
        // 引用队列
        volatile ReferenceQueue<? super T> queue;

        Reference(T referent, ReferenceQueue<? super T> queue) {
            this.referent = referent;
            this.queue = (queue == null) ? ReferenceQueue.NULL : queue;
        }
    }

从 Entry 的构造方法我们知道，key 和 queue 最终会传到到 Reference 的构造方法中，这里的 key 就是 Reference 的 referent 属性，它会被 gc 特殊对待，即当没有强引用存在时，当下一次 gc 的时候会被清除。

构造方法

    /*
     * 下面三个构造方法都是调用的这个构造方法
     * @param initialCapacity：初始容量
     * @param loadFactor：初始负载因子
     */
	public WeakHashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Initial Capacity: "+
                    initialCapacity);
        // 如果初始容量超过了最大容量，则赋值为最大容量
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;

        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal Load factor: "+
                    loadFactor);
        // capacity赋值为1
        int capacity = 1;
        // 如果capacity小于传进来的initialCapacity
        // while一直循环，直到出现一个 2的n次方的值 大于传入容量，则就是初始容量
        while (capacity < initialCapacity)
            // 将capacity左移一位，也就是capacity = capacity * 2
            capacity <<= 1;
        // 创建一个容量为 大于等于传入容量最近的2的n次方的Entry数组
        table = newTable(capacity);
        this.loadFactor = loadFactor;
        // 扩容阈值
        threshold = (int)(capacity * loadFactor);
    }

    public WeakHashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

    public WeakHashMap() {
        this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
    }

    public WeakHashMap(Map<? extends K, ? extends V> m) {
        this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
                DEFAULT_INITIAL_CAPACITY),
                DEFAULT_LOAD_FACTOR);
        putAll(m);
    }

构造方法与 HashMap 基本类似，初始容量为大于等于传入容量最近的 2 的 n 次方，扩容门槛 threshold 等于 capacity * loadFactor。

put(K key, V value)

  • 添加元素的方法。
    public V put(K key, V value) {
        // 如果key为空，用空对象代替
        Object k = maskNull(key);
        // 计算key的hash值
        int h = hash(k);
        // 获取桶
        Entry<K,V>[] tab = getTable();
        // 计算元素在哪个桶中，h & (length-1)
        int i = indexFor(h, tab.length);

        // 遍历桶对应的链表
        for (Entry<K,V> e = tab[i]; e != null; e = e.next) {
            if (h == e.hash && eq(k, e.get())) {
                // 如果找到了元素就使用新值替换旧值，并返回旧值
                V oldValue = e.value;
                if (value != oldValue)
                    e.value = value;
                return oldValue;
            }
        }

        modCount++;
        // 如果没找到就把新值插入到链表的头部
        Entry<K,V> e = tab[i];
        tab[i] = new Entry<>(k, value, queue, h, e);
        // 如果插入元素后数量达到了扩容门槛就把桶的数量扩容为2倍大小
        if (++size >= threshold)
            resize(tab.length * 2);
        return null;
    }

（1）计算 hash；

  • 这里与 HashMap 有所不同，HashMap 中如果 key 为空直接返回 0，这里是用空对象来计算的。

  • 另外打散方式也不同，HashMap 只用了一次异或，这里用了四次，HashMap 给出的解释是一次够了，而且就算冲突了也会转换成红黑树，对效率没什么影响。

（2）计算在哪个桶中；

（3）遍历桶对应的链表；

（4）如果找到元素就用新值替换旧值，并返回旧值；

（5）如果没找到就在链表头部插入新元素；

  • HashMap 就插入到链表尾部。

（6）如果元素数量达到了扩容门槛，就把容量扩大到 2 倍大小；

  • HashMap中是大于 threshold 才扩容，这里等于 threshold 就开始扩容了。

resize(int newCapacity)

  • 扩容方法。
    void resize(int newCapacity) {
        // 获取旧桶，getTable()的时候会剔除失效的Entry(key为null，被gc回收)，因为调用了expungeStaleEntries()方法，下文会讲
        Entry<K,V>[] oldTable = getTable();
        // 旧容量
        int oldCapacity = oldTable.length;
        // 如果就容量已经等于table最大容量，则直接赋值为int最大值 并返回
        if (oldCapacity == MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return;
        }

        // 新桶
        Entry<K,V>[] newTable = newTable(newCapacity);
        // 把元素从旧桶转移到新桶
        transfer(oldTable, newTable);
        // 把新桶赋值桶变量
        table = newTable;

        // 如果元素个数大于扩容门槛的一半，则使用新桶和新容量，并计算新的扩容门槛
        if (size >= threshold / 2) {
            threshold = (int)(newCapacity * loadFactor);
        } else {
            /*
             * 否则把元素再转移回旧桶，还是使用旧桶
             * 因为在transfer()的时候会清除失效的Entry，所以元素个数可能没有那么大了，就不需要扩容了
             */
            // 再次清理过期的Entry
            expungeStaleEntries();
            transfer(newTable, oldTable);
            table = oldTable;
        }
    }

    private void transfer(Entry<K,V>[] src, Entry<K,V>[] dest) {
        // 遍历旧桶
        for (int j = 0; j < src.length; ++j) {
            // 拿到当前桶位的元素
            Entry<K,V> e = src[j];
            // 将当前桶位置为null
            src[j] = null;
            // 遍历该桶位的链表
            while (e != null) {
                Entry<K,V> next = e.next;
                // 获取当前元素的key
                Object key = e.get();
                // 如果key等于了null就清除，说明key被gc清理掉了，则把整个Entry清除
                if (key == null) {
                    e.next = null;  // Help GC
                    e.value = null; //  "   "
                    size--;
                } else {
                    // 否则就计算在新桶中的位置并把这个元素放在新桶对应链表的头部
                    int i = indexFor(e.hash, dest.length);
                    e.next = dest[i];
                    dest[i] = e;
                }
                e = next;
            }
        }
    }

（1）判断旧容量是否达到最大容量；

（2）新建新桶并把元素全部转移到新桶中；

（3）如果转移后元素个数不到扩容门槛的一半，则把元素再转移回旧桶，继续使用旧桶，说明不需要扩容；

（4）否则使用新桶，并计算新的扩容门槛；

（5）转移元素的过程中会把 key 为 null 的元素清除掉，所以 size 会变小；

get(Object key)

  • 获取元素。
    public V get(Object key) {
        // 如果key为空，用空对象代替
        Object k = maskNull(key);
        // 计算hash
        int h = hash(k);
        // 返回table，并做一次expungeStaleEntries()
        Entry<K,V>[] tab = getTable();
        // 计算下标
        int index = indexFor(h, tab.length);
        // 找到所在的桶
        Entry<K,V> e = tab[index];
        // 遍历链表，找到了就返回
        while (e != null) {
            if (e.hash == h && eq(k, e.get()))
                return e.value;
            e = e.next;
        }
        // 没找到则返回null
        return null;
    }

（1）计算 hash 值；

（2）遍历所在桶对应的链表；

（3）如果找到了就返回元素的 value 值；

（4）如果没找到就返回空；

remove(Object key)

  • 移除元素。
    public V remove(Object key) {
        // 如果key为空，用空对象代替
        Object k = maskNull(key);
        // 计算hash
        int h = hash(k);
        // 返回table，并做一次expungeStaleEntries()
        Entry<K,V>[] tab = getTable();
        // 计算下标
        int i = indexFor(h, tab.length);
        // 元素所在的桶的第一个元素
        Entry<K,V> prev = tab[i];
        Entry<K,V> e = prev;

        // 遍历链表
        while (e != null) {
            Entry<K,V> next = e.next;
            if (h == e.hash && eq(k, e.get())) {
                // 如果找到了就删除元素
                modCount++;
                size--;

                if (prev == e)
                    // 如果是头节点，就把头节点指向下一个节点
                    tab[i] = next;
                else
                    // 如果不是头节点，删除该节点
                    prev.next = next;
                // 返回该节点的value值
                return e.value;
            }
            // 向后迭代
            prev = e;
            e = next;
        }
		// 没找到则返回null
        return null;
    }

（1）计算 hash；

（2）找到所在的桶；

（3）遍历桶对应的链表；

（4）如果找到了就删除该节点，并返回该节点的 value 值；

（5）如果没找到就返回 null；

expungeStaleEntries()

  • 剔除失效的 Entry（key 为 null，被 gc 回收）。
    /*
     * 当key失效的时候gc会自动把对应的Entry添加到引用队列中
     * 此方法就是将引用队列中所有的Entry从map中剔除掉
     */
	private void expungeStaleEntries() {
        // 遍历引用队列
        for (Object x; (x = queue.poll()) != null; ) {
            // 加锁
            synchronized (queue) {
                @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 (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
                        e.value = null; // Help GC
                        size--;
                        break;
                    }
                    // 向后迭代
                    prev = p;
                    p = next;
                }
            }
        }
    }

（1）当 key 失效的时候 gc 会自动把对应的 Entry 添加到这个引用队列中；

（2）所有对 map 的操作都会直接或间接地调用到这个方法先移除失效的 Entry，比如 getTable()、size()、resize()；

（3）这个方法的目的就是遍历引用队列，并把其中保存的 Entry 从 map 中移除掉，具体的过程请看类注释；

（4）从这里可以看到移除 Entry 的同时把 value 也一并置为 null 帮助 gc 清理元素，防御性编程。

使用案例

import java.util.Map;
import java.util.WeakHashMap;

public class WeakHashMapTest {
    
    public static void main(String[] args) {
        Map<String, Integer> map = new WeakHashMap<>(3);

        // 放入3个new String()声明的字符串
        map.put(new String("1"), 1);
        map.put(new String("2"), 2);
        map.put(new String("3"), 3);

        // 放入不用new String()声明的字符串
        map.put("6", 6);

        // 使用key强引用"3"这个字符串
        String key = null;
        for (String s : map.keySet()) {
            // 这个"3"和new String("3")不是一个引用
            if (s.equals("3")) {
                key = s;
            }
        }

        // 输出{6=6, 1=1, 2=2, 3=3}，未gc所有key都可以打印出来
        System.out.println(map);

        // gc一下
        System.gc();

        // 放一个new String()声明的字符串
        map.put(new String("4"), 4);

        // 输出{4=4, 6=6, 3=3}，gc后放入的值和强引用的key可以打印出来
        System.out.println(map);

        // key与"3"的引用断裂
        key = null;

        // gc一下
        System.gc();

        // 输出{6=6}，gc后强引用的key可以打印出来
        System.out.println(map);
    }
}

在这里通过 new String() 声明的变量才是弱引用，使用 “6” 这种声明方式会一直存在于常量池中，不会被清理，所以 “6” 这个元素会一直在 map 里面，其它的元素随着 gc 都会被清理掉。

总结

（1）WeakHashMap 使用 (数组 + 链表) 存储结构；

  • 单纯作为 Map 没有 HashMap 好：HashMap 在 jdk8 做了很多优化，比如单链表在过长时会转化为红黑树，降低极端
    情况下的操作复杂度。但 WeakHashMap 没有相应的优化，有点像 jdk8 之前的 HashMap 版本。

（2）WeakHashMap 中的 key 是 弱引用，gc 的时候会被清除；

（3）每次对 map 的操作都会剔除失效 key 对应的 Entry；

（4）使用 String 作为 key 时，一定要使用 new String() 这样的方式声明 key，才会失效，其它的基本类型的包装类型是一样的；

（5）WeakHashMap 常用来作为 缓存 使用；



参考文章

小成同学_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【Java-38】基于Java的WeakHashMap垃圾回收
我的笔记
01-23 367
package Weakmap; import java.util.WeakHashMap; public class About_weakmap { public static void main(String[] args) { WeakHashMap&lt;String, String&gt; map=new WeakHashMap&lt;String, String&gt;();...
WeakHashMap和HashMap的区别
wojiushimogui的博客
07-26 6602
WeakHashMap和HashMap的区别前面对HashMap的源码和WeakHashMap的源码分别进行了分析。在WeakHashMap源码分析博文中有对与HashMap区别的比较，但是不够具体系统。加上本人看了一些相关的博文，发现了一些好的例子来说明这两者的区别，因此，就有了这篇博文。WeakHashMap和HashMap一样，WeakHashMap也是一个散列表，它存储的内容也是键值对(ke
集合系列 Map（十四）：WeakedHashMap
weixin_30746117的博客
08-28 288
WeakedHashMap 也是 Map 集合的哈希实现，但其余 HashMap 的不同之处在于。其每个节点的 value 引用是弱引用，可以方便 GC 回收。 public class WeakHashMap<K,V> extends AbstractMap<K,V> implements Map<K,V> 从 WeakHashMa...
WeakHashMap
ChineseSoftware的博客
02-23 4470
一、什么是 WeakHashMap Map 的子类常见的有 HashMap、Hashtable、ConcurrentHashMap、LinkedHashMap 等。WeakHashMap，直译就是：虚弱的 HashMap。从名字可得知其和 HashMap 有关，确实如此，WeakHashMap 功能几乎和 HashMap 一致。Weak，联想java.lang.ref包下的弱引用(WeakReference)，由此这里面还牵扯到了一种弱引用结构。 二、HashMap 和 WeakHashMap 的区别 先看
WeakHashMap 垃圾回收原理
半夏_2021的博客
07-21 618
与 HashMap 区别： HashMap 的 key保留了对实际对象的 强引用，这意味着只要该HashMap对象不被销毁，该HashMap的所有Key所引用的对象就不会被垃圾回收，HashMap也不会自动删除这些Key所对应的key-value WeakHashMap的key只保留了对 实际对象的弱引用，这意味着如果WeakHashMap对象的key所引用的对象没有被其他强引用变量所一弄，则这些key所引用的对象可能被垃圾回收，WeakHashMap也可能自动删除这些Key所随影的key-value对。
WeakHashMap源码解析及使用场景
李思苇
10-26 1945
目的 让Map中不再使用的Entry被GC及时回收，释放内存空间 用途 Map本身生命周期很长，需要长期贮留内存中，但Map中的Entry可以删除，使用时可以从其它地方再次取得。 实例：tomcat中的缓存有用到。 实现方式 对于WeakReference可以参考另一篇文章：弱引用——WeakReference——所引用的对象的回收规则 在WeakHashMap类中定义了一个实例域ReferenceQueue<Map.Entry> queue。 内部的Entry直接继承了WeakRefere
WeakHashMap回收问题（包括四大引用，String内存分配）
幸平的博客
03-16 869
简单的复习了下四大引用，以及String对象的内存分配，WeakHashMap回收问题。
Java编程WeakHashMap实例解析
08-28
主要介绍了Java编程WeakHashMap实例解析，分享了相关代码示例，小编觉得还是挺不错的，具有一定借鉴价值，需要的朋友可以参考下
解析WeakHashMap与HashMap的区别详解
09-05
本篇文章是对WeakHashMap与HashMap的区别进行了详细的分析介绍，需要的朋友参考下
java集合-WeakHashMap的使用
06-14
WeakHashMap是Java中的一种特殊的哈希表实现，它使用弱引用（Weak Reference）来保存键对象。当键对象没有被其他强引用引用时，在垃圾回收时会自动从WeakHashMap中移除对应的键值对。
WeakHashMap的使用方法详解
08-29
主要介绍了WeakHashMap的使用方法详解的相关资料,希望通过本文能帮助到大家，让大家理解掌握这部分内容，需要的朋友可以参考下
Java弱引用与WeakHashMap
12-22
书中还提到可以用WeakHashMap来作为缓存的容器可以有效解决这一问题。之前也确实遇到过类似问题，但是没有接触过“弱引用”相关的问题，于是查阅了一些资料。 　《Java 理论与实践： 用弱引用堵住内存泄漏》一文也...
WeakHashMap源码分析
weixin_30692143的博客
09-09 266
前言：WeakHashMap可能平时使用的频率并不高，但是你可能听过WeakHashMap会进行自动回收吧，下面就对其原理进行分析。 注：本文jdk源码版本为jdk1.8.0_172 1.WeakHashMap介绍 WeakHashMap是一种弱引用的map，底层数据结构为数组+链表，内部的key存储为弱引用，在GC时如果key不存在强引用的情况下会被回收掉，而对于value的...
浅析WeakHashMap
技术小黑屋
07-24 331
在Java或者是Android编程中，我们一般都会使用到Map，比如HashMap这样的具体实现。更高级一点，我们可能会使用WeakHashMap。WeakHashMap...
WeakHashMap的详细理解
热门推荐
qiuhao9527的博客
06-22 3万+
WeakHashMap 继承于AbstractMap，实现了Map接口。    和HashMap一样，WeakHashMap 也是一个散列表，它存储的内容也是键值对(key-value)映射，而且键和值都可以是null。   不过WeakHashMap的键是“弱键”。在 WeakHashMap 中，当某个键不再正常使用时，会被从WeakHashMap中被自动移除。更精确地说，对于一个给定的键，其映...
Java 集合系列 13 WeakHashMap
weixin_30613727的博客
08-19 397
java 集合系列目录： Java 集合系列 01 总体框架 Java 集合系列 02 Collection架构 Java 集合系列 03 ArrayList详细介绍(源码解析)和使用示例 Java 集合系列 04 LinkedList详细介绍(源码解析)和使用示例 Java 集合系列 05 Vector详细介绍(源码解析)和使用示例 Java 集合系列 06 Stack详细介绍(源...
string模拟实现
最新发布
m0_73969414的博客
04-23 899
c++中string的模拟实现，面试必会知识点
weakhashmap
08-23
WeakHashMap 是 Java 中的一个特殊类型的 HashMap，它使用弱引用作为其 key。在普通的 HashMap 中，如果一个 key 不再被引用，但是仍然存在于 HashMap 中，那么这个 key 以及与之关联的 value 也不能被垃圾回收，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小成同学_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值