WeakHashMap

最新推荐文章于 2023-10-26 10:33:51 发布
最新推荐文章于 2023-10-26 10:33:51 发布
阅读量338 收藏
点赞数
分类专栏： JavaSE集合类 文章标签： map WeakHashMap
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Adrian_Dai/article/details/115713247
版权

1.概述

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

2.存储结构

​ WeakHashMap 因为gc的时候会把没有强引用的key回收掉，所以注定了它里面的元素不会太多，因此也就不需要像HashMap那样元素多的时候转化为红黑树来处理了。因此，WeakHashMap 的存储结构只有（数组 + 链表）

3.源码解析

3.1.属性

//很多和HashMap相同的属性不细说

//引用队列，当弱键失效的时候会把Entry添加到这个队列中
//当下次访问map的时候会把失效的Entry清除掉
private final ReferenceQueue<Object> queue = new ReferenceQueue<>();

3.2.内部类

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

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;
    }
}


//弱引用的Reference类
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;
    }

}

3.3.put添加元素

  1. 计算key 的hash值

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

    • 另外打散方式也不同，HashMap只用了一次异或，这里用了四次

      • HashMap给出的解释是一次够了，而且就算冲突了也会转换成红黑树，对效率没什么影响

  2. 计算在哪个桶中

  3. 遍历桶对应的链表

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

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

    • HashMap 就插入到链表尾部

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

    • HashMap中是大于threshold才扩容，这里等于threshold就开始扩容了
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;
}

3.4.resize扩容

  1. 判断旧容量是否达到最大容量
  2. 新建新桶并把元素全部转移到新桶中
  3. 如果转移后元素个数不到扩容门槛的一半，则把元素再转移回旧桶，继续使用旧桶，说明不需要扩容
  4. 否则使用新桶，并计算新的扩容门槛
  5. 转移元素的过程中会把key为null的元素清除掉，所以size会变小
void resize(int newCapacity) {
    // 获取旧桶，getTable()的时候会剔除失效的Entry
    Entry<K,V>[] oldTable = getTable();
    // 旧容量,判断是否达到最大容量了
    int oldCapacity = oldTable.length;
    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，所以元素个数可能没有那么大了，就不需要扩容了
        expungeStaleEntries();
        //将新桶的元素移回去旧桶，这里已经清除了失效的Entry了
        transfer(newTable, oldTable);
        table = oldTable;
    }
}


//将src桶的数据移到dest桶中
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];
        //清空旧桶
        src[j] = null;
        while (e != null) {
            Entry<K,V> next = e.next;
            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;
        }
    }
}

3.5.expungeStaleEntries清除失效的Entry

  1. 当key失效的时候gc会自动把对应的Entry添加到这个引用队列中
  2. 所有对map的操作都会直接或间接地调用到这个方法先移除失效的Entry
    • 比如 getTable()、size()、resize()
  3. 这个方法的目的就是遍历引用队列，并把其中保存的Entry从map中移除掉
    • 移除Entry的同时把value也一并置为null帮助 GC 清理元素，防御性编程
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;
                    
                    //帮助GC清理元素
                    e.value = null; // Help GC
                    size--;
                    break;
                }
                prev = p;
                p = next;
            }
        }
    }
}

3.6.remove移除元素

  1. 计算key的hash值
  2. 找到所在的桶
  3. 遍历桶对应的链表
  4. 如果找到了就删除该节点，并返回该节点的value值
  5. 如果没找到就返回null
public V remove(Object key) {
    //key是null的话，使用空对象替代
    Object k = maskNull(key);
    //计算hash值
    int h = hash(k);
    //获取桶数组
    Entry<K,V>[] tab = getTable();
    //找到key所在的桶
    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;
        //找到key所在的位置，将其从链表中移除
        if (h == e.hash && eq(k, e.get())) {
            modCount++;
            size--;
            
            if (prev == e)
                //这里是头节点的情况
                tab[i] = next;
            else
                prev.next = next;
            return e.value;
        }
        prev = e;
        e = next;
    }

    return null;
}

3.7.get获取元素

  1. 计算hash值
  2. 遍历所在桶对应的链表
  3. 如果找到了就返回元素的value值
  4. 如果没找到就返回空
public V get(Object key) {
    Object k = maskNull(key);
    //计算hash值
    int h = hash(k);
    //找到key对应的桶位置
    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;
    }
    return null;
}

强软弱虚引用

软（弱、虚）引用必须和一个引用队列（ReferenceQueue）一起使用

当gc回收这个软（弱、虚）引用引用的对象时，会把这个软（弱、虚）引用放到这个引用队列中

1.强引用

使用最普遍的引用

如果一个对象具有强引用，它绝对不会被 gc 回收

如果内存空间不足了，gc 宁愿抛出 OutOfMemoryError，也不是会回收具有强引用的对象

2.软引用

如果一个对象只具有软引用，则内存空间足够时不会回收它，但内存空间不够时就会回收这部分对象

只要这个具有软引用对象没有被回收，程序就可以正常使用

3.弱引用

如果一个对象只具有弱引用，则不管内存空间够不够，当gc扫描到它时就会回收它

4.虚引用

如果一个对象只具有虚引用，那么它就和没有任何引用一样，任何时候都可能被gc回收

ConcurrentCache

Tomcat 中的 ConcurrentCache 使用了 WeakHashMap 来实现缓存功能

ConcurrentCache 采取的是分代缓存：

  • 经常使用的对象放入 eden 中，eden 使用 ConcurrentHashMap 实现，不用担心会被回收
  • 不常用的对象放入 longterm，longterm 使用 WeakHashMap 实现，这些老对象会被垃圾收集器回收

​ 当调用 get() 方法时，会先从 eden 区获取，如果没有找到的话再到 longterm 获取，当从 longterm 获取到就把对象放入 eden 中，从而保证经常被访问的节点不容易被回收

​ 当调用 put() 方法时，如果 eden 的大小超过了 size，那么就将 eden 中的所有对象都放入 longterm 中，利用虚拟机回收掉一部分不经常使用的对象

public final class ConcurrentCache<K, V> {

    private final int size;

    private final Map<K, V> eden;

    private final Map<K, V> longterm;

    public ConcurrentCache(int size) {
        this.size = size;
        this.eden = new ConcurrentHashMap<>(size);
        this.longterm = new WeakHashMap<>(size);
    }

    public V get(K k) {
        V v = this.eden.get(k);
        if (v == null) {
            v = this.longterm.get(k);
            if (v != null)
                this.eden.put(k, v);
        }
        return v;
    }

    public void put(K k, V v) {
        if (this.eden.size() >= size) {
            this.longterm.putAll(this.eden);
            this.eden.clear();
        }
        this.eden.put(k, v);
    }
}
Adrian_Dai
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
WeakHashMap的使用方法详解
08-29
主要介绍了WeakHashMap的使用方法详解的相关资料,希望通过本文能帮助到大家，让大家理解掌握这部分内容，需要的朋友可以参考下
Java中的WeakHashMap
借你一秒
04-28 7793
楔子 WeakHashMap，此种Map的特点是，当除了自身有对key的引用外，此key没有其他引用那么此map会自动丢弃此值，所以比较适合做缓存。 WeakHashMap的这种特性比较适合实现类似本地、堆内缓存的存储机制——缓存的失效依赖于GC收集器的行为 WeakHashMap的定义如下: public class WeakHashMap<K,V> extends Abstract...
WeakHashMap源码分析
weixin_30692143的博客
09-09 266
前言：WeakHashMap可能平时使用的频率并不高，但是你可能听过WeakHashMap会进行自动回收吧，下面就对其原理进行分析。 注：本文jdk源码版本为jdk1.8.0_172 1.WeakHashMap介绍 WeakHashMap是一种弱引用的map，底层数据结构为数组+链表，内部的key存储为弱引用，在GC时如果key不存在强引用的情况下会被回收掉，而对于value的...
Java 集合系列 13 WeakHashMap
weixin_30613727的博客
08-19 398
java 集合系列目录： Java 集合系列 01 总体框架 Java 集合系列 02 Collection架构 Java 集合系列 03 ArrayList详细介绍(源码解析)和使用示例 Java 集合系列 04 LinkedList详细介绍(源码解析)和使用示例 Java 集合系列 05 Vector详细介绍(源码解析)和使用示例 Java 集合系列 06 Stack详细介绍(源...
解析WeakHashMap与HashMap的区别详解
09-05
本篇文章是对WeakHashMap与HashMap的区别进行了详细的分析介绍，需要的朋友参考下
java集合-WeakHashMap的使用
06-14
WeakHashMap是Java中的一种特殊的哈希表实现，它使用弱引用（Weak Reference）来保存键对象。当键对象没有被其他强引用引用时，在垃圾回收时会自动从WeakHashMap中移除对应的键值对。
Java弱引用与WeakHashMap
12-22
书中还提到可以用WeakHashMap来作为缓存的容器可以有效解决这一问题。之前也确实遇到过类似问题，但是没有接触过“弱引用”相关的问题，于是查阅了一些资料。 　《Java 理论与实践： 用弱引用堵住内存泄漏》一文也...
Java编程WeakHashMap实例解析
08-28
主要介绍了Java编程WeakHashMap实例解析，分享了相关代码示例，小编觉得还是挺不错的，具有一定借鉴价值，需要的朋友可以参考下
java WeakHashMap详细介绍(源码解析)和使用示例
Code-lover's Learning Notes
07-21 1255
概要 这一章，我们对WeakHashMap进行学习。 我们先对WeakHashMap有个整体认识，然后再学习它的源码，最后再通过实例来学会使用WeakHashMap。 第1部分 WeakHashMap介绍 第2部分 WeakHashMap数据结构 第3部分 WeakHashMap源码解析(基于JDK1.6.0_45) 第4部分 WeakHashMap遍历方式 第5部分 WeakH
一文带你了解WeakHashMap
shkstart的博客
06-29 1052
1. WeakHashMap的适用场景 大部分的缓存都需要占用内存，考虑到内存的有限性，并不能缓存所有的对象，此时就需要用到另类的集合，例如WeakHashMap，可以保存一些对象的同时淘汰另一些对象，以此减少存储成本。 2. 什么是WeakHashMap WeakHashMap，是在HashMap的基础上多了Weak。表示这是一个弱引用的HashMap。 来看下WeakHashMap的类定义： public class WeakHashMap<K,V> extends Abstract
弄懂WeakHashMap实现原理，争取早日成为Java技术专家
qq_64513388的博客
11-26 667
跟HashMap一样，WeakHashMap也是一个哈希表。它比HashMap多出来的功能就是，存储在WeakHashMap中且没有被其他地方引用的key可以被GC回收，而如果把key保存在HashMap中，则无论这个key在其他地方有没有被引用，这个key一直驻留在JVM内存，从而产生泄漏的风险。 我们知道，对于弱引用WeakReference而言，只要发生一次GC，它内部引用的对象就会立即被GC回收。所以说WeakHashMap的key是一个weak key，把key和value放入WeakHashM
java 软引用，弱引用，强引用
m0_49218532的博客
10-04 186
4种引用类型： 强引用，弱引用，软引用，虚引用。 引用类型优点： 1.可以通过代码控制对象的生命周期。 2.便于jvm进行垃圾回收。 强引用： 只有引用释放对象才被回收，这是常见的new出来的对象。 也可以将引用赋值为null，中断引用和对象之间的关联。jvm会在合适的时间回收该对象。 软引用： 软引用关联着的对象，只有内存不足的时候jvm才会回收该对象。适合用来实现缓存，网页缓存，图片缓存。 弱引用： 描述非必须的对象，无论内存是否满足，该对象都会被回收。主要用于监控对象是否被垃圾回收器标记为即将回收对象
WeakHashMap源码解析
How many ten years in the life time?
12-21 386
WeakHashMap 是一种 弱引用 map，内部的 key 会存储为弱引用，当 jvm gc 的时候，如果这些 key 没有强引用存在的话，会被 gc 回收掉，下一次当我们操作 map 的时候会把对应的 Entry 整个删除掉，基于这种特性，WeakHashMap 特别适用于 缓存 处理。 WeakHashMap 因为 gc 的时候会把没有强引用的 key 回收掉，所以注定了它里面的元素不会太多，因此也就不需要像 HashMap 那样元素多的时候转化为红黑树来处理了。 因此，WeakHashMap 的
Java还要再学一遍基础（十一）WeakHashMap详解
LightOfMiracle的博客
06-07 525
WeakHashMap概述WeakHashMap是以弱键实现的基于哈希表的存储映射数据的Map。当JVM对于这些弱键所指向的对象进行了清理回收之后，WeakHashMap会自动有效的将被回收了的映射从map中移除。引用的相关知识Java中的引用一共分为四种，分别为强引用（Strong Reference），软引用（Soft Reference），弱引用（Weak Reference）和幻影引用（Ph
WeakHashMap 源码解析
最新发布
流华追梦的专栏
10-26 82
WeakHashMap，从名字可以看出它是某种 Map。它的特殊之处在于 WeakHashMap 里的entry可能会被GC自动删除，即使程序员没有调用remove()或者clear()方法。更直观的说，当使用 WeakHashMap 时，即使没有显示的添加或删除任何元素，也可能发生如下情况：1. 调用两次size()方法返回不同的值；2. 两次调用isEmpty()方法，第一次返回false，第二次返回true；
WeakHashMap源码解析及使用场景
李思苇
10-26 1945
目的 让Map中不再使用的Entry被GC及时回收，释放内存空间 用途 Map本身生命周期很长，需要长期贮留内存中，但Map中的Entry可以删除，使用时可以从其它地方再次取得。 实例：tomcat中的缓存有用到。 实现方式 对于WeakReference可以参考另一篇文章：弱引用——WeakReference——所引用的对象的回收规则 在WeakHashMap类中定义了一个实例域ReferenceQueue<Map.Entry> queue。 内部的Entry直接继承了WeakRefere
WeakHashMap理解
渣渣
08-11 731
一、什么是WeakHashMap？ 从名字可以得知主要和Map有关，不过还有一个Weak，我们就更能自然而然的想到这里面还牵扯到一种弱引用结构，因此想要彻底搞懂，我们还需要知道四种引用。如果你已经知道了，可以跳过。 1、四种引用 在jvm中，一个对象如果不再被使用就会被当做垃圾给回收掉，判断一个对象是否是垃圾，通常有两种方法：引用计数法和可达性分析法。不管是哪一种方法判断一个对象是否是垃圾的条件总是一个对象的引用是都没有了。 JDK.1.2 之后，Java 对引用的概念进行了扩充，将引用分为了：强引
weakhashmap
08-23
WeakHashMap 是 Java 中的一个特殊类型的 HashMap，它使用弱引用作为其 key。在普通的 HashMap 中，如果一个 key 不再被引用，但是仍然存在于 HashMap 中，那么这个 key 以及与之关联的 value 也不能被垃圾回收，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值