深读源码-java集合之WeakHashMap源码分析

2023-11-07 09:32

本文主要是介绍深读源码-java集合之WeakHashMap源码分析,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

简介

WeakHashMap 继承于AbstractMap,实现了Map接口。
    和HashMap一样,WeakHashMap 也是一个散列表,它存储的内容也是键值对(key-value)映射,而且键和值都可以是null
   不过WeakHashMap的键是“弱键”。在 WeakHashMap 中,当某个键不再正常使用时,会被从WeakHashMap中被自动移除。更精确地说,对于一个给定的键,其映射的存在并不阻止垃圾回收器对该键的丢弃,这就使该键成为可终止的,被终止,然后被回收。某个键被终止时,它对应的键值对也就从映射中有效地移除了。
    这个“弱键”的原理呢?大致上就是,通过WeakReference和ReferenceQueue实现的。 WeakHashMap的key是“弱键”,即是WeakReference类型的;ReferenceQueue是一个队列,它会保存被GC回收的“弱键”。实现步骤是:
    (1) 新建WeakHashMap,将“键值对”添加到WeakHashMap中。
           实际上,WeakHashMap是通过数组table保存Entry(键值对);每一个Entry实际上是一个单向链表,即Entry是键值对链表。
    (2) 当某“弱键”不再被其它对象引用,并被GC回收时。在GC回收该“弱键”时,这个“弱键”也同时会被添加到ReferenceQueue(queue)队列中。
    (3) 当下一次我们需要操作WeakHashMap时,会先同步table和queue。table中保存了全部的键值对,而queue中保存被GC回收的键值对;同步它们,就是删除table中被GC回收的键值对
    这就是“弱键”如何被自动从WeakHashMap中删除的步骤了。

继承体系

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

存储结构

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

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

源码解析

属性

// 默认的初始容量是16,必须是2的幂。
private static final int DEFAULT_INITIAL_CAPACITY = 16;// 最大容量(必须是2的幂且小于2的30次方,传入容量过大将被这个值替换)
private static final int MAXIMUM_CAPACITY = 1 << 30;// 默认加载因子
private static final float DEFAULT_LOAD_FACTOR = 0.75f;// 存储数据的Entry数组,长度是2的幂。
// WeakHashMap是采用拉链法实现的,每一个Entry本质上是一个单向链表
private Entry[] table;// WeakHashMap的大小,它是WeakHashMap保存的键值对的数量
private int size;// WeakHashMap的阈值,用于判断是否需要调整WeakHashMap的容量(threshold = 容量*加载因子)
private int threshold;// 加载因子实际大小
private final float loadFactor;// queue保存的是“已被GC清除”的“弱引用的键”。
// 弱引用和ReferenceQueue 是联合使用的:如果弱引用所引用的对象被垃圾回收,Java虚拟机就会把这个弱引用加入到与之关联的引用队列中
private final ReferenceQueue<K> queue = new ReferenceQueue<K>();// WeakHashMap被改变的次数
private volatile int modCount;

(1)容量

容量为数组的长度,亦即桶的个数,默认为16,最大为2的30次方。

(2)装载因子

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

(3)引用队列

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

Entry内部类

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

private static class Entry<K,V> extends WeakReference<Object> implements Map.Entry<K,V> {// 可以发现没有key, 因为key是作为弱引用存到Referen类中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;}
}

WeakReference是“弱键”实现的哈希表。它这个“弱键”的目的就是:实现对“键值对”的动态回收。当“弱键”不再被使用到时,GC会回收它,WeakReference也会将“弱键”对应的键值对删除。
    “弱键”是一个“弱引用(WeakReference)”,在Java中,WeakReference和ReferenceQueue 是联合使用的。在WeakHashMap中亦是如此:如果弱引用所引用的对象被垃圾回收,Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。 接着,WeakHashMap会根据“引用队列”,来删除“WeakHashMap中已被GC回收的‘弱键’对应的键值对”。
    另外,理解上面思想的重点是通过 expungeStaleEntries() 函数去理解。

构造方法

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);int capacity = 1;while (capacity < initialCapacity)capacity <<= 1;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;
}//计算hash
final int hash(Object k) {int h = k.hashCode();h ^= (h >>> 20) ^ (h >>> 12);return h ^ (h >>> 7) ^ (h >>> 4);
}

(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()的时候会剔除失效的EntryEntry<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 ignoring null elements and processing ref queue caused massive* shrinkage, then restore old table.  This should be rare, but avoids* unbounded expansion of garbage-filled tables.*/// 如果元素个数大于扩容门槛的一半,则使用新桶和新容量,并计算新的扩容门槛if (size >= threshold / 2) {threshold = (int)(newCapacity * loadFactor);} else {// 否则把元素再转移回旧桶,还是使用旧桶// 因为在transfer的时候会清除失效的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];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 GCe.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) {Object k = maskNull(key);// 计算hashint h = hash(k);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;
}

(1)计算hash值;

(2)遍历所在桶对应的链表;

(3)如果找到了就返回元素的value值;

(4)如果没找到就返回空;

remove(Object key)方法

移除元素。

public V remove(Object key) {Object k = maskNull(key);// 计算hashint h = hash(k);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;return e.value;}prev = e;e = next;}return null;
}

(1)计算hash;

(2)找到所在的桶;

(3)遍历桶对应的链表;

(4)如果找到了就删除该节点,并返回该节点的value值;

(5)如果没找到就返回null;

expungeStaleEntries()方法

剔除失效的Entry。

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;elseprev.next = next;// Must not null out e.next;// stale entries may be in use by a HashIteratore.value = null; // Help GCsize--;break;}prev = p;p = next;}}}
}

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

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

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

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

使用案例

说了这么多,不举个使用的例子怎么过得去。

package com.coolcoding.code;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使用(数组 + 链表)存储结构;

(2)WeakHashMap中的key是弱引用,gc的时候会被清除;

(3)每次对map的操作都会剔除失效key对应的Entry;

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

(5)WeakHashMap常用来作为缓存使用;

彩蛋

强、软、弱、虚引用知多少?

(1)强引用

使用最普遍的引用。如果一个对象具有强引用,它绝对不会被gc回收。如果内存空间不足了,gc宁愿抛出OutOfMemoryError,也不是会回收具有强引用的对象。

(2)软引用

如果一个对象只具有软引用,则内存空间足够时不会回收它,但内存空间不够时就会回收这部分对象。只要这个具有软引用对象没有被回收,程序就可以正常使用。

(3)弱引用

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

(4)虚引用

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

软(弱、虚)引用必须和一个引用队列(ReferenceQueue)一起使用,当gc回收这个软(弱、虚)引用引用的对象时,会把这个软(弱、虚)引用放到这个引用队列中。

比如,上述的Entry是一个弱引用,它引用的对象是key,当key被回收时,Entry会被放到queue中。


参考链接:https://www.cnblogs.com/tong-yuan/p/10639404.html

参考链接:https://www.cnblogs.com/skywang12345/p/3311092.html

这篇关于深读源码-java集合之WeakHashMap源码分析的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/362739

相关文章

如何在 Spring Boot 中实现 FreeMarker 模板

《如何在SpringBoot中实现FreeMarker模板》FreeMarker是一种功能强大、轻量级的模板引擎,用于在Java应用中生成动态文本输出(如HTML、XML、邮件内容等),本文... 目录什么是 FreeMarker 模板?在 Spring Boot 中实现 FreeMarker 模板1. 环

SpringMVC 通过ajax 前后端数据交互的实现方法

《SpringMVC通过ajax前后端数据交互的实现方法》:本文主要介绍SpringMVC通过ajax前后端数据交互的实现方法,本文给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价... 在前端的开发过程中,经常在html页面通过AJAX进行前后端数据的交互,SpringMVC的controll

Java中的工具类命名方法

《Java中的工具类命名方法》:本文主要介绍Java中的工具类究竟如何命名,本文给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友参考下吧... 目录Java中的工具类究竟如何命名?先来几个例子几种命名方式的比较到底如何命名 ?总结Java中的工具类究竟如何命名?先来几个例子JD

Java Stream流使用案例深入详解

《JavaStream流使用案例深入详解》:本文主要介绍JavaStream流使用案例详解,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友参考下吧... 目录前言1. Lambda1.1 语法1.2 没参数只有一条语句或者多条语句1.3 一个参数只有一条语句或者多

Spring Security自定义身份认证的实现方法

《SpringSecurity自定义身份认证的实现方法》:本文主要介绍SpringSecurity自定义身份认证的实现方法,下面对SpringSecurity的这三种自定义身份认证进行详细讲解,... 目录1.内存身份认证(1)创建配置类(2)验证内存身份认证2.JDBC身份认证(1)数据准备 (2)配置依

SpringBoot整合OpenFeign的完整指南

《SpringBoot整合OpenFeign的完整指南》OpenFeign是由Netflix开发的一个声明式Web服务客户端,它使得编写HTTP客户端变得更加简单,本文为大家介绍了SpringBoot... 目录什么是OpenFeign环境准备创建 Spring Boot 项目添加依赖启用 OpenFeig

Java Spring 中 @PostConstruct 注解使用原理及常见场景

《JavaSpring中@PostConstruct注解使用原理及常见场景》在JavaSpring中,@PostConstruct注解是一个非常实用的功能,它允许开发者在Spring容器完全初... 目录一、@PostConstruct 注解概述二、@PostConstruct 注解的基本使用2.1 基本代

springboot使用Scheduling实现动态增删启停定时任务教程

《springboot使用Scheduling实现动态增删启停定时任务教程》:本文主要介绍springboot使用Scheduling实现动态增删启停定时任务教程,具有很好的参考价值,希望对大家有... 目录1、配置定时任务需要的线程池2、创建ScheduledFuture的包装类3、注册定时任务,增加、删

SpringBoot整合mybatisPlus实现批量插入并获取ID详解

《SpringBoot整合mybatisPlus实现批量插入并获取ID详解》这篇文章主要为大家详细介绍了SpringBoot如何整合mybatisPlus实现批量插入并获取ID,文中的示例代码讲解详细... 目录【1】saveBATch(一万条数据总耗时:2478ms)【2】集合方式foreach(一万条数

IntelliJ IDEA 中配置 Spring MVC 环境的详细步骤及问题解决

《IntelliJIDEA中配置SpringMVC环境的详细步骤及问题解决》:本文主要介绍IntelliJIDEA中配置SpringMVC环境的详细步骤及问题解决,本文分步骤结合实例给大... 目录步骤 1:创建 Maven Web 项目步骤 2:添加 Spring MVC 依赖1、保存后执行2、将新的依赖