参考自https://blog.csdn.net/weixin_44460333/article/details/86770169
扩容：https://zhuanlan.zhihu.com/p/114363420
目录
1、HashMap
1.1、JDK1.7
1.1.1、数据结构图
- 当出现Hash冲突的时候，在桶上形成链表，这样有一个缺点，就是当冲突严重时，桶中的链表会很长，时间复杂度会增加
1.1.2、源码变/常量
- DEFAULT_INITIAL_CAPACITY，初始化桶的大小，桶是由数组实现，所以就是默认数组的长度，默认值是16（1<<4，2的4次方）
- MAXIMUM_CAPACITY，桶的最大值，默认值是1073741824（1<<30，2的30次方）
- DEFAULT_LOAD_FACTOR，默认的负载因子，0.75。当map中存放的数据达到16*0.75=12时需要扩容，扩容需要消耗资源
- EMPTY_TABLE，真正存放数据的数组
- size，存放数量的大小
- threshold，自定义桶的大小
- loadFactor，自定义负载因子
1.1.3、put方法
1 public V put(K key, V value) {
2 if (table == EMPTY_TABLE) {
3 inflateTable(threshold);
4 }
5 if (key == null)
6 return putForNullKey(value);
7 int hash = hash(key);
8 int i = indexFor(hash, table.length);
9 for (Entry<K,V> e = table[i]; e != null; e = e.next) {
10 Object k;
11 if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
12 V oldValue = e.value;
13 e.value = value;
14 e.recordAccess(this);
15 return oldValue;
16 }
17 }
18
19 modCount++;
20 addEntry(hash, key, value, i);
21 return null;
22 }
-
判断当前数组是否需要初始化。
-
如果 key 为空，则 put 一个空值进去。
-
根据 key 计算出 hashcode。（计算hashcode使用的是本地方法）
-
根据计算出的 hashcode 定位出所在桶。
-
如果桶是一个链表则需要遍历判断里面的 hashcode、key 是否和传入 key 相等，如果相等则进行覆盖，并返回原来的值。
-
如果桶是空的，说明当前位置没有数据存入；新增一个 Entry 对象写入当前位置
1 void addEntry(int hash, K key, V value, int bucketIndex) {
2 if ((size >= threshold) && (null != table[bucketIndex])) {
3 resize(2 * table.length);
4 hash = (null != key) ? hash(key) : 0;
5 bucketIndex = indexFor(hash, table.length);
6 }
7
8 createEntry(hash, key, value, bucketIndex);
9 }
10
11 void createEntry(int hash, K key, V value, int bucketIndex) {
12 Entry<K,V> e = table[bucketIndex];
13 table[bucketIndex] = new Entry<>(hash, key, value, e);
14 size++;
15 }
- 当调用 addEntry 写入 Entry 时需要判断是否需要扩容
- 如果需要就进行两倍扩充，并将当前的 key 重新 hash 并定位。
- 如果需要就进行两倍扩充，并将当前的 key 重新 hash 并定位。
1.1.4、多线程死循环问题
1.1.5、get方法
1 public V get(Object key) {
2 if (key == null)
3 return getForNullKey();
4 Entry<K,V> entry = getEntry(key);
5
6 return null == entry ? null : entry.getValue();
7 }
8
9 final Entry<K,V> getEntry(Object key) {
10 if (size == 0) {
11 return null;
12 }
13
14 int hash = (key == null) ? 0 : hash(key);
15 for (Entry<K,V> e = table[indexFor(hash, table.length)];
16 e != null;
17 e = e.next) {
18 Object k;
19 if (e.hash == hash &&
20 ((k = e.key) == key || (key != null && key.equals(k))))
21 return e;
22 }
23 return null;
24 }
-
首先也是根据 key 计算出 hashcode，然后定位到具体的桶中。
-
判断该位置是否为链表。
-
不是链表就根据
key、key 的 hashcode是否相等来返回值。 -
为链表则需要遍历直到 key 及 hashcode 相等时候就返回值。
-
啥都没取到就直接返回 null 。
1.2、JDK1.8
1.2.1、数据结构图
- 当Hash冲突严重时，链表长度超过一定限度之后，使用红黑树来组织同中的数据
1.2.2、源码变/常量
- 和JDK1.7中一样，除此之外，有一些和红黑树相关的量
- TREEIFY_THRESHOLD=8，当链表转为红黑树的阈值
- UNTREEIFY_THRESHOLD=6，当红黑树中的数据少于阈值时，将红黑树转为链表
- MIN_TREEIFY_CAPACITY=64，当map中的容量超过阈值时，才能将链表转为红黑树，64是16的4倍
1.2.3、put方法
-
判断当前桶是否为空，空的就需要初始化（resize 中会判断是否进行初始化）。
-
根据当前 key 的 hashcode 定位到具体的桶中并判断是否为空，为空表明没有 Hash 冲突就直接在当前位置创建一个新桶即可。
-
如果当前桶有值（ Hash 冲突），那么就要比较当前桶中的
key、key 的 hashcode与写入的 key 是否相等，相等就赋值给e,在第 8 步的时候会统一进行赋值及返回。 -
如果当前桶为红黑树，那就要按照红黑树的方式写入数据。
-
如果是个链表，就需要将当前的 key、value 封装成一个新节点写入到当前桶的后面（形成链表）。
-
接着判断当前链表的大小是否大于预设的阈值，大于时就要转换为红黑树。
-
如果在遍历过程中找到 key 相同时直接退出遍历。
-
如果
e != null就相当于存在相同的 key,那就需要将值覆盖。 -
最后判断是否需要进行扩容。
1.2.4、get方法
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
/**
* Implements Map.get and related methods
*
* @param hash hash for key
* @param key the key
* @return the node, or null if none
*/
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
if ((e = first.next) != null) {
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}-
首先将 key hash 之后取得所定位的桶。
-
如果桶为空则直接返回 null 。
-
否则判断桶的第一个位置(有可能是链表、红黑树)的 key 是否为查询的 key，是就直接返回 value。
-
如果第一个不匹配，则判断它的下一个是红黑树还是链表。
-
红黑树就按照树的查找方式返回值。
-
不然就按照链表的方式遍历匹配返回值。
1.2.5、HashMap扩容（待补充）
2、ConcurrentHashMap
2.1、JDK1.7中的ConcurrentHashMap
2.1.1、数据结构图
- 由Segment数组、HashEntry组成，和HashMap一样，依旧是数组加链表，segment是数组，HashEntry是链表
2.1.2、变/常量
- 核心成员变量Segment<K,V>[] segments，数组
- Set<K> keySet，数组
- Set<Map.Entry<K,V>> entrySet，数组
1 /**
2 * Segment 数组，存放数据时首先需要定位到具体的 Segment 中。
3 */
4 final Segment<K,V>[] segments;
5
6 transient Set<K> keySet;
7 transient Set<Map.Entry<K,V>> entrySet;
- segments是ConcurrentHashMap 的一个内部类，
1 static final class Segment<K,V> extends ReentrantLock implements Serializable {
2
3 private static final long serialVersionUID = 2249069246763182397L;
4 // 和 HashMap 中的 HashEntry 作用一样，真正存放数据的桶
5 transient volatile HashEntry<K,V>[] table;
6 transient int count;
7 transient int modCount;
8 transient int threshold;
9 final float loadFactor;
10 }
- HashEntry组成
- 总的来说，JDK1.7中的ConcurrentHashMap和HashMap是类似的，区别就是value、链表都是由volatile修饰的，保证修改可见性
2.1.2、原理
- ConcurrentHashMap 采用了分段锁技术，其中 Segment 继承于 ReentrantLock可重用锁（所以是在Segment使用锁），所以不用像HashTable那样在put和get的时候都需要做同步处理
2.1.3、put方法
- 首先通过key定位到Segment（数组），然后在Segment中的链表进行插入
1 public V put(K key, V value) {
2 Segment<K,V> s;
3 if (value == null)
4 throw new NullPointerException();
5 int hash = hash(key);
6 int j = (hash >>> segmentShift) & segmentMask;
7 if ((s = (Segment<K,V>)UNSAFE.getObject // nonvolatile; recheck
8 (segments, (j << SSHIFT) + SBASE)) == null) // in ensureSegment
9 s = ensureSegment(j);
10 return s.put(key, hash, value, false);
11 }
1 final V put(K key, int hash, V value, boolean onlyIfAbsent) {
2 HashEntry<K,V> node = tryLock() ? null :
3 scanAndLockForPut(key, hash, value);
4 V oldValue;
5 try {
6 HashEntry<K,V>[] tab = table;
7 int index = (tab.length - 1) & hash;
8 HashEntry<K,V> first = entryAt(tab, index);
9 for (HashEntry<K,V> e = first;;) {
10 if (e != null) {
11 K k;
12 if ((k = e.key) == key ||
13 (e.hash == hash && key.equals(k))) {
14 oldValue = e.value;
15 if (!onlyIfAbsent) {
16 e.value = value;
17 ++modCount;
18 }
19 break;
20 }
21 e = e.next;
22 }
23 else {
24 if (node != null)
25 node.setNext(first);
26 else
27 node = new HashEntry<K,V>(hash, key, value, first);
28 int c = count + 1;
29 if (c > threshold && tab.length < MAXIMUM_CAPACITY)
30 rehash(node);
31 else
32 setEntryAt(tab, index, node);
33 ++modCount;
34 count = c;
35 oldValue = null;
36 break;
37 }
38 }
39 } finally {
40 unlock();
41 }
42 return oldValue;
43 }
- HashEntry中的value是使用volatile关键字修饰了，但是不能保证并发的原子性，所以put操作时需要加锁
- 第一步先尝试获取锁，如果获取失败，则利用scanAndLockForPut()自旋获取锁，直到通过key定位到HashEntry
- 遍历该 HashEntry，如果不为空则判断传入的 key 和当前遍历的 key 是否相等，相等则覆盖旧的 value。
- 不为空则需要新建一个 HashEntry 并加入到 Segment 中，同时会先判断是否需要扩容。
- 最后会解除在 1 中所获取当前 Segment 的锁。
- 自旋锁
- 尝试自旋获取锁。
- 如果重试的次数达到了
MAX_SCAN_RETRIES则改为阻塞锁获取，保证能获取成功。
2.1.4、get方法
1 public V get(Object key) {
2 Segment<K,V> s; // manually integrate access methods to reduce overhead
3 HashEntry<K,V>[] tab;
4 int h = hash(key);
5 long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
6 if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&
7 (tab = s.table) != null) {
8 for (HashEntry<K,V> e = (HashEntry<K,V>) UNSAFE.getObjectVolatile
9 (tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE);
10 e != null; e = e.next) {
11 K k;
12 if ((k = e.key) == key || (e.hash == h && key.equals(k)))
13 return e.value;
14 }
15 }
16 return null;
17 }
- 将 Key 通过 Hash 之后定位到具体的 Segment
- 再通过一次 Hash 定位到具体的元素上
- 由于 HashEntry 中的 value 属性是用 volatile 关键词修饰的，保证了内存可见性，所以每次获取时都是最新值。
- ConcurrentHashMap 的 get 方法是非常高效的，因为整个过程都不需要加锁。
2.2、JDK1.8中的ConcurrentHashMap
- JDK1.7中遍历链表效率太低了
2.2.1、数据结构图
2.2.1、原理
- JDK1.8中，抛弃了原来的Segment锁（JDK7中使用可重入锁），采用
CAS + synchronized来保证并发安全性 - 将JDK1.7中存放数据的HashEntry改为Node，但是作用一样，其中value和next均使用volatile修饰
2.2.2、put方法
-
根据 key 计算出 hashcode后遍历找到数组中的节点 。
-
判断整个表是否需要进行初始化。
-
f即为当前 key 定位出的 Node，如果为空表示当前位置可以写入数据，利用 CAS 尝试写入，失败则自旋保证成功。在真正要写入数据的时候才加锁，之前找的时候都不用加 -
如果当前位置的
hashcode == MOVED == -1,则需要进行扩容。 -
如果都不满足，则利用 synchronized 锁写入数据。
-
如果数量大于
TREEIFY_THRESHOLD则要转换为红黑树。
2.2.3、get方法
-
根据计算出来的 hashcode 寻址，如果就在桶上那么直接返回值。
-
如果是红黑树那就按照树的方式获取值。
-
就不满足那就按照链表的方式遍历获取值。
2.2.4、JDK8改动
- 采用红黑树之后可以保证查询效率（
O(logn)） - 甚至取消了 ReentrantLock 改为了 synchronized，这样可以看出在新版的 JDK 中对 synchronized 优化是很到位的
扫一扫
8万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
