JDK1.7 HashMap底层结构如下:
HashMap底层是基于 数组+链表 实现的。其中重要的两个参数
- 容量
- 负载因子
默认的初始容量大小是16,负载因子是0.75,当 HashMap 的 size > 16*0.75 时就会发生扩容,扩容这个过程涉及到rehash、复制数据等操作,很耗性能。我们可以通过预估容量大小来减少扩容次数
负载因子:
public HashMap() {
this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}
public HashMap(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);
this.loadFactor = loadFactor;
threshold = initialCapacity;
init();
}
put 方法
首先会将传入的 key 的 hash 运算计算出 hashcode,然后根据数组长度取模计算出数组中的 index 下标。由于在计算中位运算比取模运算效率高的多,所以 HashMap 规定数组的长度为 2^n,这样用 2^n - 1,做位运算与取模效果一致,并且效率高,由于数组的长度有限,不同的 key 通过运算得到的 index 相同,这种情况下可以利用链表来解决,HashMap 会在 table[index] 处形成链表 ,采用头插法将数据插入到链表中。
get 方法
将传入的 key 计算出 index ,如果该位置上是一个链表就需要遍历整个链表,通过 key.equal(key) 来找到对应的元素
public V get(Object key) {
if (key == null)
return getForNullKey();
Entry<K,V> entry = getEntry(key);
return null == entry ? null : entry.getValue();
}
final Entry<K,V> getEntry(Object key) {
if (size == 0) {
return null;
}
int hash = (key == null) ? 0 : hash(key);
for (Entry<K,V> e = table[indexFor(hash, table.length)];
e != null;
e = e.next) {
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
}
return null;
}
注: 当Hash冲突严重时,在桶上形成的链表就会越来越长,这样查询时的效率就会越来越低,时间复杂度为 O(n)
JDK1.8后的优化
1.8之后的 ConcurrentHashMap 抛弃了原有的Segment 分段锁,而采用了 CAS + synchronized 来保证并发安全性,底层实现也改为了 数组+链表+红黑树,当链表节点较多时(大于8)会转为红黑树,红黑树的查找时,会反复用到以下两条规则:
1) 如果目标节点的hash值小于 p 节点的 hash 值,则向 p 节点的左边遍历,否则向 p 节点的右边遍历
2)如果目标节点的 key 值小于 p 节点的 key 值,则向 p 节点的左边遍历;否则向 p 节点的右边遍历。这两条规则是利用了红黑树的特性(左节点<根结点<右节点)
修改为红黑树之后查询的时间复杂度为O(logn)
HashMap 的遍历代码推荐
terator<Map.Entry<String, Integer>> entryIterator = map.entrySet().iterator();
while (entryIterator.hasNext()) {
Map.Entry<String, Integer> next = entryIterator.next();
System.out.println("key=" + next.getKey() + " value=" + next.getValue());
}
ConcurrentHashMap
解析:
如图所示,ConcurrentHashMap
由Segment数组、HashEntry 组成,和 HashMap 一样,仍然是数组加链表
ConcurrentHashMap
采用了分段锁技术,其中Segment继承于ReentrantLock。不会像 HashTable 那样不管是 put 还是 get 操作都需要做同步处理,理论上ConcurrentHashMap
支持 CurrencyLevel(Segment数组数量)的线程并发,每当一个线程占用锁访问一个 Segment 时,不会影响到其他的 Segment
get 方法
ConcurrentHashMap
的 get 方法,不需要任何加锁的操作,只需要将key 通过 hash 之后定位到具体的 Segment,再通过一次 Hash 定位到具体的元素上,由于 HashEntry 中的 value 属性是用 volatile 关键词修饰的,保证了内存可见性,所以保证了每次获取都是最新值
put 方法
内部的HashEntry 类:
static final class HashEntry<K,V> {
final int hash;
final K key;
volatile V value;
volatile HashEntry<K,V> next;
HashEntry(int hash, K key, V value, HashEntry<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
}
虽然 HashEntity 中的 value 是用 volatile 关键词修饰,但是并不能保证并发的原子性,所以put操作时仍然需要加锁处理,首先通过 Key 的 Hash 定位到具体的Sement,在 put 之前会进行一次扩容校验,这里比 HashMap 要好的一点是:ConcurrentHashMap 扩容操作是在操作之前决定的,而HashMap是数据插入后,再检查是否需要扩容,后者直接导致扩容后没有后续操作,浪费了一次扩容(扩容很消耗性能);
size 方法
每个 Segment 都有一个volatile 修饰的全局变量 count,求整个 ConcurrentHashMap 的 size 时很明显就是将所有的 count 累加即可,但是 volatile 修饰的变量却不能保证多线程下的原子性,所以直接累加很容易出现并发问题,但如果每次调用 size 方法将其余的修改操作加锁,效率也不是很高,所以做法为先尝试两次 将 count 累加,如果容器的 count 发生了变化 再加锁来统计 size,而 ConcurrentHashMap 是如何检测统计时的发生了变化?每个 Segment 都有一个 modCount 变量,每次进行一次 put remove 等操作,modeCount 将会 +1,只要modCount 发生了变化就会认为 容器的大小也发生了变化