hashmap源码剖析

hashmap

底层实现

HashMap.Entry数组，数组+拉链

static class Entry<K,V> implements Map.Entry<K,V> {    final K key;    V value;    Entry<K,V> next;    final int hash;}

• Entry对象代表了HashMap中的一个元素（键值对）
• hashCode相同（碰撞）的元素将分配到Entry数组的同一个桶中
• 同一个桶中的Entry对象由next域串联起来，构成一个单向链式结构

初始化

• 默认容量DEFAULT_INITIAL_CAPACITY是16
• 默认负载因子DEFAULT_LOAD_FACTOR是0.75
• 若指定的初始容量initialCapacity大于MAXIMUM_CAPACITY，会重置为MAXIMUM_CAPACITY

• HashMap实际的容量大于等于指定的容量initialCapacity，因为hashmap的容量是2的幂，如果initialCapacity不是2的幂，实际容量将设置为比initialCapacity大的最小的2的幂值

  int capacity = 1;while (capacity < initialCapacity)    capacity <<= 1;

• 如果使用另一个map进行初始化，负载因子会使用DEFAULT_LOAD_FACTOR，容量会在(int) (m.size() / DEFAULT_LOAD_FACTOR) + 1和DEFAULT_INITIAL_CAPACITY中取大者

• 调用 init() 方法（空实现，LinkedHashMap会重写这个方法）

put

• 如果键已经存在，用新值覆盖旧值并返回旧值
• 如果键已经存在，会调用recordAccess方法，凡是访问了HashMap中元素的方法，都会调用recordAccess方法，在HashMap中是空实现，在LinkedHashMap会重写这个方法
• 如果键不存在，会调用addEntry方法，创建一个新的Entry对象，放到Entry数组对应的桶中，成为拉链的第一个元素
• 如果键不存在，添加了新元素之后，会判断是否需要扩容。如果size>=threshold，则进行2倍扩容（注意，如果容量已经等于最大容量MAXIMUM_CAPACITY，只把threshold改为Integer.MAX_VALUE，而不扩容）。创建新的Entry数组，并将当前数组中的元素迁移到新的数组中（重新计算每个元素在新数组中的索引）
• 如果键不存在，modCount++，size++，modCount是用来记录结构性修改次数的，凡是修改了底层结构的操作都会令modCount加1，modCount主要用于迭代器的快速失败，迭代器将根据modCount的值是否发生了变化来判断是否有其他进程对HashMap做了修改

几点注意事项

• null的hashCode定义为0，如果key==null，将设置到table[0]中

• hash算法（h是传入的key的hashCode）

  h ^= (h >>> 20) ^ (h >>> 12);return h ^ (h >>> 7) ^ (h >>> 4);

• 根据hash定位数组索引的算法

  h & (length-1)

• 判断key是否存在的方法

  e.hash == hash && ((k = e.key) == key || key.equals(k))

remove

• 计算key在Entry数组中的索引，在桶中查找键相等的元素（equals）
• 如果找到了，将前一节点的next指向当前节点的下一个节点（单链表的删除操作）并返回当前节点
• 如果找到了，modCount++，size--，调用recordRemoval方法，凡是删除了HashMap中元素的方法都会调用recordRemoval，在HashMap中是空实现，在LinkedHashMap会重写这个方法
• 最终将返回节点（Entry对象）的value值

get

• 计算key在Entry数组中的索引（如果key==null，索引是0）
• 遍历当前桶中的元素，如果找到key相等的元素（equals），返回元素的值

keySet

• 返回keySet对象

• keySet是HashMap中的一个内部类，继承了AbstractSet，KeySet的remove和clear方法可以直接修改HashMap本身的内容。因为，KeySet只不过是HashMap的一个视图而已

  private final class KeySet extends AbstractSet<K> {    public Iterator<K> iterator() {        return newKeyIterator();    }    public int size() {        return size;    }    public boolean contains(Object o) {        return containsKey(o);    }    public boolean remove(Object o) {        return HashMap.this.removeEntryForKey(o) != null;    }    public void clear() {        HashMap.this.clear();    }}

• keySet的iterator方法调用了外部类（HashMap）的newKeyIterator方法，newKeyIterator将返回一个KeyIterator对象，KeyIterator继承了HashIterator。LinkedHashMap重写了newKeyIterator方法。

• HashIterator中的域，expectedModCount初始化为modCount，index初始化为第一个不为空的桶的索引+1，next初始化为第一个不为空的桶中拉链的第一个元素。

  private abstract class HashIterator<E> implements Iterator<E> {    Entry<K,V> next;    // next entry to return    int expectedModCount;   // For fast-fail    int index;      // current slot    Entry<K,V> current; // current entry}HashIterator() {    expectedModCount = modCount;    if (size > 0) { // advance to first entry        Entry[] t = table;        while (index < t.length && (next = t[index++]) == null)            ;    }}

• next方法。迭代的方案是，按照索引从小到大（大于0，小于table.length）遍历每一个桶，如果桶不为空，则遍历这个桶中拉链的每个元素。每次被遍历到的元素将赋值给current，current对于下一次操作而言，保存了上一个返回的元素。

  while (index < t.length && (next = t[index++]) == null);  //风骚的代码

• remove方法。如果current==null，将抛出异常，这说明在调用remove方法之前必须先调用next，删除current.key对应的元素，最后expectedModCount = modCount，这是因为删除操作会使得modCount++，而这次的删除操作并不是并发操作引起的，因此重置expectedModCount，以免触发快速失败。

• 在调用next和remove时，有个快速失败（fast-fail）机制

  if (modCount != expectedModCount)    throw new ConcurrentModificationException();

containsKey

• 计算key在数组中的索引，遍历桶中的所有元素，如果存在key，则返回true，否则返回false

containsValue

• 遍历所有的桶中的所有元素，如果找到值equals的，则返回true，否则返回true，否则返回false
• 这个方法效率蛮低的

LinkedHashMap

底层实现

LinkedHashMap.Entry数组：数组+拉链+双向循环链表

• LinkedHashMap继承了HashMap

• LinkedHashMap的内部类Entry继承了HashMap.Entry，多了before和after两个域，用于实现双向循环链表，而原有的next域是用于桶中拉链的单向链表的，不要搞混了。

  private static class Entry<K,V> extends HashMap.Entry<K,V> {    // These fields comprise the doubly linked list used for iteration.    Entry<K,V> before, after;}

初始化

• LinkedHashMap中多了一个 accessOrder 域，表示排序的方式，如果 accessOrder 是true，按照访问顺序排序，否则，按照插入顺序排序
• 调用父类（HashMap）的构造方法， accessOrder 默认为 false
• 重载的构造方法可以传入 accessOrder 参数

• 调用 init() 方法，LinkedHashMap重载了HashMap的 init() 方法，用于初始化双向循环链表头节点 header

  void init() {    header = new Entry<K,V>(-1, null, null, null);    header.before = header.after = header;}

put

• 如果键已经存在，用新值覆盖旧值并返回旧值

• 如果键已经存在，会调用recordAccess方法，凡是访问了HashMap中元素的方法，都会调用recordAccess方法，在HashMap中是空实现，LinkedHashMap重写了这个方法，如果accessOrder等于true，modCount++，从双向循环链表中删除当前节点，并把当前节点插入到header之前

  void recordAccess(HashMap<K,V> m) {    LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;    if (lm.accessOrder) {        lm.modCount++;        remove();        addBefore(lm.header);    }}

• 如果键不存在，会调用addEntry方法，LinkedHashMap重写了HashMap的addEntry方法，创建一个新的Entry对象，放到Entry数组对应的桶中，成为拉链的第一个元素，并在双向循环链表中把新节点插入到header之前

  void createEntry(int hash, K key, V value, int bucketIndex) {    HashMap.Entry<K,V> old = table[bucketIndex];    Entry<K,V> e = new Entry<K,V>(hash, key, value, old);    table[bucketIndex] = e;    e.addBefore(header);    size++;}

• 如果键不存在，添加了新元素之后，会判断是否需要扩容。如果size>=threshold，则进行2倍扩容（注意，如果容量已经等于最大容量MAXIMUM_CAPACITY，只把threshold改为Integer.MAX_VALUE，而不扩容）。创建新的Entry数组，并将当前数组中的元素迁移到新的数组中（重新计算每个元素在新数组中的索引）

• 如果键不存在，modCount++，size++，modCount是用来记录结构性修改次数的，凡是修改了底层结构的操作都会令modCount加1，modCount主要用于迭代器的快速失败，迭代器将根据modCount的值是否发生了变化来判断是否有其他进程对HashMap做了修改

get

• 调用HashMap的get方法
  
  • 计算key在Entry数组中的索引（如果key==null，索引是0）
  • 遍历当前桶中的元素，如果找到key相等的元素（equals），返回元素的值
• 如果返回是 null ，则返回 null

• 否则在返回值之前调用 recordAccess 方法，LinkedHashMap重写了这个方法，如果accessOrder等于true，modCount++，从双向循环链表中删除当前节点，并把当前节点插入到header之前

  void recordAccess(HashMap<K,V> m) {    LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;    if (lm.accessOrder) {        lm.modCount++;        remove();        addBefore(lm.header);    }}

remove

• 计算key在Entry数组中的索引，在桶中查找键相等的元素（equals）
• 如果找到了，将前一节点的next指向当前节点的下一个节点（单链表的删除操作）并返回当前节点

• 如果找到了，modCount++，size--，调用recordRemoval方法，凡是删除了HashMap中元素的方法都会调用recordRemoval，在HashMap中是空实现，在LinkedHashMap会重写这个方法，将元素从双向循环链表中移除

  void recordRemoval(HashMap<K,V> m) {    remove();}

• 最终将返回节点（Entry对象）的value值

keySet

• 返回keySet对象

• keySet是HashMap中的一个内部类，继承了AbstractSet，KeySet的remove和clear方法可以直接修改HashMap本身的内容。因为，KeySet只不过是HashMap的一个视图而已

  private final class KeySet extends AbstractSet<K> {    public Iterator<K> iterator() {        return newKeyIterator();    }    public int size() {        return size;    }    public boolean contains(Object o) {        return containsKey(o);    }    public boolean remove(Object o) {        return HashMap.this.removeEntryForKey(o) != null;    }    public void clear() {        HashMap.this.clear();    }}

• keySet的iterator方法调用了外部类（HashMap）的newKeyIterator方法，LinkedHashMap重写了newKeyIterator方法，newKeyIterator将返回一个KeyIterator对象，KeyIterator继承了LinkedHashIterator。

• LinkedHashIterator中的域，expectedModCount初始化为modCount，lastReturned保存最近一次迭代返回的元素，初始化为null，nextEntry保存下一次迭代返回的元素，初始化为header后的第一个元素，即第一个插入或者访问的元素。

  private abstract class LinkedHashIterator<T> implements Iterator<T> {Entry<K,V> nextEntry    = header.after;Entry<K,V> lastReturned = null;int expectedModCount = modCount;

• next方法。迭代的方案是，从header的下一个元素开始，按照双向循环链表的正向遍历。将本次返回的元素赋值给lastReturned，对于下一次操作而言，lastReturned保存了最近一次迭代返回的元素

• remove方法。如果lastReturned==null，将抛出异常，这说明在调用remove方法之前必须先调用next，删除lastReturned.key对应的元素，最后expectedModCount = modCount，这是因为删除操作会使得modCount++，而这次的删除操作并不是并发操作引起的，因此重置expectedModCount，以免触发快速失败。

• 在调用next和remove时，有个快速失败（fast-fail）机制

  if (modCount != expectedModCount)    throw new ConcurrentModificationException();

ConcurrentHashMap

底层实现

ConcurrentHashMap.Segment数组 + ConcurrentHashMap.HashEntry数组

• ConcurrentHashMap将整个map分为若干段（Segment）
• 读写时，仅对当前段加锁，通过这种方式来减少对整个map加锁造成的效率损失
• 每个段（Segment）都拥有自己的HashEntry数组，相当于每个段都是一个HashMap
• 定位元素时，先根据hashCode定位所在的段，再根据hashCode定位所在的桶，最后再在拉链中定位元素（equals）。

• Segment，注意count、table是volatile的

  transient volatile int count;transient int modCount;transient int threshold;transient volatile HashEntry<K,V>[] table;final float loadFactor;

• HashEntry，注意key、hash、next是final的，value是volatile的

  static final class HashEntry<K,V> {    final K key;    final int hash;    volatile V value;    final HashEntry<K,V> next;    HashEntry(K key, int hash, HashEntry<K,V> next, V value) {        this.key = key;        this.hash = hash;        this.next = next;        this.value = value;    }}

初始化

• 默认容量DEFAULT_INITIAL_CAPACITY是16
• 默认负载因子DEFAULT_LOAD_FACTOR是0.75
• 默认段数组容量DEFAULT_CONCURRENCY_LEVEL是16

• 初始化段数组（Segment<K,V>[] segments）。

  this.segments = Segment.newArray(ssize);

  • 计算段数组容量ssize。若指定的容量concurrencyLevel大于MAX_SEGMENTS，会重置为MAX_SEGMENTS，实际的容量大于等于concurrencyLevel，因为容量是2的幂，如果concurrencyLevel不是2的幂，实际容量将置为比concurrencyLevel大的最小的2的幂值

    int ssize = 1;while (ssize < concurrencyLevel) {    //...    ssize <<= 1;}

  • 计算segmentMask

  • 计算segmentShift

• 为每个段初始化HashEntry数组

  for (int i = 0; i < this.segments.length; ++i)    this.segments[i] = new Segment<K,V>(cap, loadFactor);

  • 计算HashEntry数组的容量cap。若指定的容量initialCapacity大于MAXIMUM_CAPACITY，会重置为MAXIMUM_CAPACITY，根据initialCapacity / ssize计算每个段中的容量并向上取为2的幂

    int c = initialCapacity / ssize;if (c * ssize < initialCapacity)    ++c;int cap = 1;while (cap < c)    cap <<= 1;

put

• value不允许为null，事实上，key也不能为null，因为计算hash值时会调用key.hashCode()，如果key为null的话会抛出空指针异常。HashMap允许key和value为null，这里不一样。
• 计算hash值

• 根据hash值计算在段数组中的索引

  final Segment<K,V> segmentFor(int hash) {    return segments[(hash >>> segmentShift) & segmentMask];}

• 调用对应段对象的put方法

Segment的put

• 判断是否需要扩容。计算count+1是否大于threshold，如果大于，进行2倍扩容（如果容量已经大于等于最大容量MAXIMUM_CAPACITY，直接返回，不扩容）。创建新的Entry数组，并将当前数组中的元素迁移到新的数组中（重新计算每个元素在新数组中的索引，具体算法太风骚，没有看懂，稍后再看）
• 如果键已经存在，用新值覆盖旧值并返回旧值
• 如果键不存在，创建一个新的HashEntry对象，放到HashEntry数组对应的桶中，成为拉链的第一个元素，并返回null
• 如果键不存在，modCount++，size++，modCount是用来记录结构性修改次数的，凡是修改了底层结构的操作都会令modCount加1，modCount主要用于迭代器的快速失败，迭代器将根据modCount的值是否发生了变化来判断是否有其他进程对HashMap做了修改

几点注意事项

• hash算法（h是传入的key的hashCode）

  h += (h <<  15) ^ 0xffffcd7d;h ^= (h >>> 10);h += (h <<   3);h ^= (h >>>  6);h += (h <<   2) + (h << 14);return h ^ (h >>> 16);

• 根据hash定位数组索引的算法

  int index = hash & (tab.length - 1);

• put，remove等写方法会对当前的段加锁，这是保障并发访问的关键所在，get方法不会加锁，除非需要value等于null的特殊情况（HashEntry中只有value不是final的，因此有可能被重排序到构造函数之外进行初始化）

  lock();try {    //...} finally {    unlock();}    

get

• key不能为null，因为计算hash值时会调用key.hashCode()，如果key为null的话会抛出空指针异常。HashMap允许key为null，这里不一样。
• 计算hash值
• 根据hash值计算在段数组中的索引
• 调用对应段对象的get方法

Segment的get

• 如果count==0，直接返回null
• 计算key所在的索引，并取桶中的第一个节点开始遍历，如果找到key相等的元素（equals），将返回对应的value。
• 找到key相等的元素后，会检查value是否为null，如果不为null直接返回，如果为null，将通过加锁的方式取得value并返回。正常情况下value的值不应该为null，为null说明了某些编译器对HashEntry的初始化做了重排序，通过加锁的方式取得value，将会等到新增HashEntry的操作全部结束后才去试图获得value的值。
• get之所以不用加锁，是因为HashEntry的value是volatile的

remove

• key不能为null，因为计算hash值时会调用key.hashCode()，如果key为null的话会抛出空指针异常。HashMap允许key为null，这里不一样。
• 计算hash值
• 根据hash值计算在段数组中的索引
• 调用对应段对象的remove方法

Segment的remove

• 计算key在HashEntry数组中的索引，在桶中查找键相等的元素（equals）

• 如果找到了，链表中该节点之后的节点不用动，该节点之前的每个元素拷贝一份。为什么不直接将节点从链表中摘除呢？这是因为HashEntry中的key，next，hash都是final的，一经初始化，不能修改，因此需要把节点之前的元素全部拷贝一份新的。（那么问题来了，为什么设计成final的呢？参见JMM-final）

  HashEntry<K,V> newFirst = e.next;for (HashEntry<K,V> p = first; p != e; p = p.next)    newFirst = new HashEntry<K,V>(p.key, p.hash,                                  newFirst, p.value);tab[index] = newFirst;

  1 -> 2 -> 3 -> 4 -> 5 - > 6移除4后将变为3 -> 2 -> 1 -> 5 -> 6

• 如果找到了，modCount++，count--

• 返回被删除节点（HashEntry对象）的value值

size

• 不加锁的计算size，第一次循环，对每个段的count求和sum，并把每个段的modCount保存下来。第二次循环，再次对每个段的count求和check，并检查这次的modCount是否和上次的一样。如果每个段的modCount都没有变，且check=sum，则返回sum，否则，重试。（最多进行RETRIES_BEFORE_LOCK次）

• 对所有段加锁，循环，对每个段的count求和sum，对所有段解锁，返回sum

  sum = 0;for (int i = 0; i < segments.length; ++i)    segments[i].lock();for (int i = 0; i < segments.length; ++i)    sum += segments[i].count;for (int i = 0; i < segments.length; ++i)    segments[i].unlock();

keySet

• 返回keySet对象

• keySet是ConcurrentHashMap中的一个内部类，继承了AbstractSet，KeySet的remove和clear方法可以直接修改HashMap本身的内容。因为，KeySet只不过是HashMap的一个视图而已

  final class KeySet extends AbstractSet<K> {    public Iterator<K> iterator() {        return new KeyIterator();    }    public int size() {        return ConcurrentHashMap.this.size();    }    public boolean contains(Object o) {        return ConcurrentHashMap.this.containsKey(o);    }    public boolean remove(Object o) {        return ConcurrentHashMap.this.remove(o) != null;    }    public void clear() {        ConcurrentHashMap.this.clear();    }}

• keySet的iterator方法返回一个KeyIterator对象，KeyIterator继承了HashIterator。
• 遍历的顺序，按照Segment数组从后向前，HashEntry数组从后向前，拉链从头向为的顺序遍历
• ConcurrentHashMap的迭代器没有使用快速失败机制，在遍历过程中，如果已经遍历的数组上的内容变化了，迭代器不会抛出ConcurrentModificationException异常。如果未遍历的数组上的内容发生了变化，则有可能反映到迭代过程中。（参见 弱一致性迭代器）

思考

• 为什么key和value不允许为null？## LinkedHashMap