Java7和8 中的 HashMap 和 ConcurrentHashMap 全解析

public V put(K key, V value) {

    // 当插入第一个元素的时候，需要先初始化数组大小

    if (table == EMPTY_TABLE) {

        inflateTable(threshold);

    }

    // 如果 key 为 null，感兴趣的可以往里看，最终会将这个 entry 放到 table[0] 中

    if (key == null)

        return putForNullKey(value);

    // 1\. 求 key 的 hash 值

    int hash = hash(key);

    // 2\. 找到对应的数组下标

    int i = indexFor(hash, table.length);

    // 3\. 遍历一下对应下标处的链表，看是否有重复的 key 已经存在，

    //    如果有，直接覆盖，put 方法返回旧值就结束了

    for (Entry<K,V> e = table[i]; e != null; e = e.next) {

        Object k;

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

            V oldValue = e.value;

            e.value = value;

            e.recordAccess(this);

            return oldValue;

        }

    }



    modCount++;

    // 4\. 不存在重复的 key，将此 entry 添加到链表中，细节后面说

    addEntry(hash, key, value, i);

    return null;

}

private void inflateTable(int toSize) {

    // 保证数组大小一定是 2 的 n 次方。

    // 比如这样初始化：new HashMap(20)，那么处理成初始数组大小是 32

    int capacity = roundUpToPowerOf2(toSize);

    // 计算扩容阈值：capacity * loadFactor

    threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);

    // 算是初始化数组吧

    table = new Entry[capacity];

    initHashSeedAsNeeded(capacity); //ignore

}

static int indexFor(int hash, int length) {

    // assert Integer.bitCount(length) == 1 : "length must be a non-zero power of 2";

    return hash & (length-1);

}

void addEntry(int hash, K key, V value, int bucketIndex) {

    // 如果当前 HashMap 大小已经达到了阈值，并且新值要插入的数组位置已经有元素了，那么要扩容

    if ((size >= threshold) && (null != table[bucketIndex])) {

        // 扩容，后面会介绍一下

        resize(2 * table.length);

        // 扩容以后，重新计算 hash 值

        hash = (null != key) ? hash(key) : 0;

        // 重新计算扩容后的新的下标

        bucketIndex = indexFor(hash, table.length);

    }

    // 往下看

    createEntry(hash, key, value, bucketIndex);

}

// 这个很简单，其实就是将新值放到链表的表头，然后 size++

void createEntry(int hash, K key, V value, int bucketIndex) {

    Entry<K,V> e = table[bucketIndex];

    table[bucketIndex] = new Entry<>(hash, key, value, e);

    size++;

}

void resize(int newCapacity) {

    Entry[] oldTable = table;

    int oldCapacity = oldTable.length;

    if (oldCapacity == MAXIMUM_CAPACITY) {

        threshold = Integer.MAX_VALUE;

        return;

    }

    // 新的数组

    Entry[] newTable = new Entry[newCapacity];

    // 将原来数组中的值迁移到新的更大的数组中

    transfer(newTable, initHashSeedAsNeeded(newCapacity));

    table = newTable;

    threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);

}

public V get(Object key) {

    // 之前说过，key 为 null 的话，会被放到 table[0]，所以只要遍历下 table[0] 处的链表就可以了

    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;

}

public ConcurrentHashMap(int initialCapacity,

                         float loadFactor, int concurrencyLevel) {

    if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)

        throw new IllegalArgumentException();

    if (concurrencyLevel > MAX_SEGMENTS)

        concurrencyLevel = MAX_SEGMENTS;

    // Find power-of-two sizes best matching arguments

    int sshift = 0;

    int ssize = 1;

    // 计算并行级别 ssize，因为要保持并行级别是 2 的 n 次方

    while (ssize < concurrencyLevel) {

        ++sshift;

        ssize <<= 1;

    }

    // 我们这里先不要那么烧脑，用默认值，concurrencyLevel 为 16，sshift 为 4

    // 那么计算出 segmentShift 为 28，segmentMask 为 15，后面会用到这两个值

    this.segmentShift = 32 - sshift;

    this.segmentMask = ssize - 1;



    if (initialCapacity > MAXIMUM_CAPACITY)

        initialCapacity = MAXIMUM_CAPACITY;



    // initialCapacity 是设置整个 map 初始的大小，

    // 这里根据 initialCapacity 计算 Segment 数组中每个位置可以分到的大小

    // 如 initialCapacity 为 64，那么每个 Segment 或称之为"槽"可以分到 4 个

    int c = initialCapacity / ssize;

    if (c * ssize < initialCapacity)

        ++c;

    // 默认 MIN_SEGMENT_TABLE_CAPACITY 是 2，这个值也是有讲究的，因为这样的话，对于具体的槽上，

    // 插入一个元素不至于扩容，插入第二个的时候才会扩容

    int cap = MIN_SEGMENT_TABLE_CAPACITY; 

    while (cap < c)

        cap <<= 1;



    // 创建 Segment 数组，

    // 并创建数组的第一个元素 segment[0]

    Segment<K,V> s0 =

        new Segment<K,V>(loadFactor, (int)(cap * loadFactor),

                         (HashEntry<K,V>[])new HashEntry[cap]);

    Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize];

    // 往数组写入 segment[0]

    UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]

    this.segments = ss;

}

public V put(K key, V value) {

    Segment<K,V> s;

    if (value == null)

        throw new NullPointerException();

    // 1\. 计算 key 的 hash 值

    int hash = hash(key);

    // 2\. 根据 hash 值找到 Segment 数组中的位置 j

    //    hash 是 32 位，无符号右移 segmentShift(28) 位，剩下低 4 位，

    //    然后和 segmentMask(15) 做一次与操作，也就是说 j 是 hash 值的最后 4 位，也就是槽的数组下标

    int j = (hash >>> segmentShift) & segmentMask;

    // 刚刚说了，初始化的时候初始化了 segment[0]，但是其他位置还是 null，

    // ensureSegment(j) 对 segment[j] 进行初始化

    if ((s = (Segment<K,V>)UNSAFE.getObject          // nonvolatile; recheck

         (segments, (j << SSHIFT) + SBASE)) == null) //  in ensureSegment

        s = ensureSegment(j);

    // 3\. 插入新值到 槽 s 中

    return s.put(key, hash, value, false);

}

final V put(K key, int hash, V value, boolean onlyIfAbsent) {

    // 在往该 segment 写入前，需要先获取该 segment 的独占锁

    //    先看主流程，后面还会具体介绍这部分内容

    HashEntry<K,V> node = tryLock() ? null :

        scanAndLockForPut(key, hash, value);

    V oldValue;

    try {

        // 这个是 segment 内部的数组

        HashEntry<K,V>[] tab = table;

        // 再利用 hash 值，求应该放置的数组下标

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

        // first 是数组该位置处的链表的表头

        HashEntry<K,V> first = entryAt(tab, index);



        // 下面这串 for 循环虽然很长，不过也很好理解，想想该位置没有任何元素和已经存在一个链表这两种情况

        for (HashEntry<K,V> e = first;;) {

            if (e != null) {

                K k;

                if ((k = e.key) == key ||

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

                    oldValue = e.value;

                    if (!onlyIfAbsent) {

                        // 覆盖旧值

                        e.value = value;

                        ++modCount;

                    }

                    break;

                }

                // 继续顺着链表走

                e = e.next;

            }

            else {

                // node 到底是不是 null，这个要看获取锁的过程，不过和这里都没有关系。

                // 如果不为 null，那就直接将它设置为链表表头；如果是null，初始化并设置为链表表头。

                if (node != null)

                    node.setNext(first);

                else

                    node = new HashEntry<K,V>(hash, key, value, first);



                int c = count + 1;

                // 如果超过了该 segment 的阈值，这个 segment 需要扩容

                if (c > threshold && tab.length < MAXIMUM_CAPACITY)

                    rehash(node); // 扩容后面也会具体分析

                else

                    // 没有达到阈值，将 node 放到数组 tab 的 index 位置，

                    // 其实就是将新的节点设置成原链表的表头

                    setEntryAt(tab, index, node);

                ++modCount;

                count = c;

                oldValue = null;

                break;

            }

        }

    } finally {

        // 解锁

        unlock();

    }

    return oldValue;

}

private Segment<K,V> ensureSegment(int k) {

    final Segment<K,V>[] ss = this.segments;

    long u = (k << SSHIFT) + SBASE; // raw offset

    Segment<K,V> seg;

    if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u)) == null) {

        // 这里看到为什么之前要初始化 segment[0] 了，

        // 使用当前 segment[0] 处的数组长度和负载因子来初始化 segment[k]

        // 为什么要用“当前”，因为 segment[0] 可能早就扩容过了

        Segment<K,V> proto = ss[0];

        int cap = proto.table.length;

        float lf = proto.loadFactor;

        int threshold = (int)(cap * lf);



        // 初始化 segment[k] 内部的数组

        HashEntry<K,V>[] tab = (HashEntry<K,V>[])new HashEntry[cap];

        if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))

            == null) { // 再次检查一遍该槽是否被其他线程初始化了。



            Segment<K,V> s = new Segment<K,V>(lf, threshold, tab);

            // 使用 while 循环，内部用 CAS，当前线程成功设值或其他线程成功设值后，退出

            while ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))

                   == null) {

                if (UNSAFE.compareAndSwapObject(ss, u, null, seg = s))

                    break;

            }

        }

    }

    return seg;

}

private HashEntry<K,V> scanAndLockForPut(K key, int hash, V value) {

    HashEntry<K,V> first = entryForHash(this, hash);

    HashEntry<K,V> e = first;

    HashEntry<K,V> node = null;

    int retries = -1; // negative while locating node



    // 循环获取锁

    while (!tryLock()) {

        HashEntry<K,V> f; // to recheck first below

        if (retries < 0) {

            if (e == null) {

                if (node == null) // speculatively create node

                    // 进到这里说明数组该位置的链表是空的，没有任何元素

                    // 当然，进到这里的另一个原因是 tryLock() 失败，所以该槽存在并发，不一定是该位置

                    node = new HashEntry<K,V>(hash, key, value, null);

                retries = 0;

            }

            else if (key.equals(e.key))

                retries = 0;

            else

                // 顺着链表往下走

                e = e.next;

        }

        // 重试次数如果超过 MAX_SCAN_RETRIES（单核1多核64），那么不抢了，进入到阻塞队列等待锁

        //    lock() 是阻塞方法，直到获取锁后返回

        else if (++retries > MAX_SCAN_RETRIES) {

            lock();

            break;

        }

        else if ((retries & 1) == 0 &&

                 // 这个时候是有大问题了，那就是有新的元素进到了链表，成为了新的表头

                 //     所以这边的策略是，相当于重新走一遍这个 scanAndLockForPut 方法

                 (f = entryForHash(this, hash)) != first) {

            e = first = f; // re-traverse if entry changed

            retries = -1;

        }

    }

    return node;

}

// 方法参数上的 node 是这次扩容后，需要添加到新的数组中的数据。

private void rehash(HashEntry<K,V> node) {

    HashEntry<K,V>[] oldTable = table;

    int oldCapacity = oldTable.length;

    // 2 倍

    int newCapacity = oldCapacity << 1;

    threshold = (int)(newCapacity * loadFactor);

    // 创建新数组

    HashEntry<K,V>[] newTable =

        (HashEntry<K,V>[]) new HashEntry[newCapacity];

    // 新的掩码，如从 16 扩容到 32，那么 sizeMask 为 31，对应二进制 ‘000...00011111’

    int sizeMask = newCapacity - 1;



    // 遍历原数组，老套路，将原数组位置 i 处的链表拆分到 新数组位置 i 和 i+oldCap 两个位置

    for (int i = 0; i < oldCapacity ; i++) {

        // e 是链表的第一个元素

        HashEntry<K,V> e = oldTable[i];

        if (e != null) {

            HashEntry<K,V> next = e.next;

            // 计算应该放置在新数组中的位置，

            // 假设原数组长度为 16，e 在 oldTable[3] 处，那么 idx 只可能是 3 或者是 3 + 16 = 19

            int idx = e.hash & sizeMask;

            if (next == null)   // 该位置处只有一个元素，那比较好办

                newTable[idx] = e;

            else { // Reuse consecutive sequence at same slot

                // e 是链表表头

                HashEntry<K,V> lastRun = e;

                // idx 是当前链表的头结点 e 的新位置

                int lastIdx = idx;



                // 下面这个 for 循环会找到一个 lastRun 节点，这个节点之后的所有元素是将要放到一起的

                for (HashEntry<K,V> last = next;

                     last != null;

                     last = last.next) {

                    int k = last.hash & sizeMask;

                    if (k != lastIdx) {

                        lastIdx = k;

                        lastRun = last;

                    }

                }

                // 将 lastRun 及其之后的所有节点组成的这个链表放到 lastIdx 这个位置

                newTable[lastIdx] = lastRun;

                // 下面的操作是处理 lastRun 之前的节点，

                //    这些节点可能分配在另一个链表中，也可能分配到上面的那个链表中

                for (HashEntry<K,V> p = e; p != lastRun; p = p.next) {

                    V v = p.value;

                    int h = p.hash;

                    int k = h & sizeMask;

                    HashEntry<K,V> n = newTable[k];

                    newTable[k] = new HashEntry<K,V>(h, p.key, v, n);

                }

            }

        }

    }

    // 将新来的 node 放到新数组中刚刚的 两个链表之一 的 头部

    int nodeIndex = node.hash & sizeMask; // add the new node

    node.setNext(newTable[nodeIndex]);

    newTable[nodeIndex] = node;

    table = newTable;

}

public V get(Object key) {

    Segment<K,V> s; // manually integrate access methods to reduce overhead

    HashEntry<K,V>[] tab;

    // 1\. hash 值

    int h = hash(key);

    long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;

    // 2\. 根据 hash 找到对应的 segment

    if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&

        (tab = s.table) != null) {

        // 3\. 找到segment 内部数组相应位置的链表，遍历

        for (HashEntry<K,V> e = (HashEntry<K,V>) UNSAFE.getObjectVolatile

                 (tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE);

             e != null; e = e.next) {

            K k;

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

                return e.value;

        }

    }

    return null;

}

public int size() {

final Segment<K,V>[] segments = this.segments;

int size;

boolean overflow; // true if size overflows 32 bits

long sum; // sum of modCounts

long last = 0L; // previous sum

int retries = -1; // first iteration isn't retry

try {

for (;;) {

if (retries++ == RETRIES_BEFORE_LOCK) {

for (int j = 0; j < segments.length; ++j)

ensureSegment(j).lock(); // force creation

}

sum = 0L;

size = 0;

overflow = false;

for (int j = 0; j < segments.length; ++j) {

Segment<K,V> seg = segmentAt(segments, j);

if (seg != null) {

sum += seg.modCount;

int c = seg.count;

if (c < 0 || (size += c) < 0)

overflow = true;

}

}

if (sum == last)

break;

last = sum;

}

} finally {

if (retries > RETRIES_BEFORE_LOCK) {

for (int j = 0; j < segments.length; ++j)

segmentAt(segments, j).unlock();

}

}

return overflow ? Integer.MAX_VALUE : size;

}

public V put(K key, V value) {

    return putVal(hash(key), key, value, false, true);

}



// 第三个参数 onlyIfAbsent 如果是 true，那么只有在不存在该 key 时才会进行 put 操作

// 第四个参数 evict 我们这里不关心

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,

               boolean evict) {

    Node<K,V>[] tab; Node<K,V> p; int n, i;

    // 第一次 put 值的时候，会触发下面的 resize()，类似 java7 的第一次 put 也要初始化数组长度

    // 第一次 resize 和后续的扩容有些不一样，因为这次是数组从 null 初始化到默认的 16 或自定义的初始容量

    if ((tab = table) == null || (n = tab.length) == 0)

        n = (tab = resize()).length;

    // 找到具体的数组下标，如果此位置没有值，那么直接初始化一下 Node 并放置在这个位置就可以了

    if ((p = tab[i = (n - 1) & hash]) == null)

        tab[i] = newNode(hash, key, value, null);



    else {// 数组该位置有数据

        Node<K,V> e; K k;

        // 首先，判断该位置的第一个数据和我们要插入的数据，key 是不是"相等"，如果是，取出这个节点

        if (p.hash == hash &&

            ((k = p.key) == key || (key != null && key.equals(k))))

            e = p;

        // 如果该节点是代表红黑树的节点，调用红黑树的插值方法，本文不展开说红黑树

        else if (p instanceof TreeNode)

            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);

        else {

            // 到这里，说明数组该位置上是一个链表

            for (int binCount = 0; ; ++binCount) {

                // 插入到链表的最后面(Java7 是插入到链表的最前面)

                if ((e = p.next) == null) {

                    p.next = newNode(hash, key, value, null);

                    // TREEIFY_THRESHOLD 为 8，所以，如果新插入的值是链表中的第 8 个

                    // 会触发下面的 treeifyBin，也就是将链表转换为红黑树

                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st

                        treeifyBin(tab, hash);

                    break;

                }

                // 如果在该链表中找到了"相等"的 key(== 或 equals)

                if (e.hash == hash &&

                    ((k = e.key) == key || (key != null && key.equals(k))))

                    // 此时 break，那么 e 为链表中[与要插入的新值的 key "相等"]的 node

                    break;

                p = e;

            }

        }

        // e!=null 说明存在旧值的key与要插入的key"相等"

        // 对于我们分析的put操作，下面这个 if 其实就是进行 "值覆盖"，然后返回旧值

        if (e != null) {

            V oldValue = e.value;

            if (!onlyIfAbsent || oldValue == null)

                e.value = value;

            afterNodeAccess(e);

            return oldValue;

        }

    }

    ++modCount;

    // 如果 HashMap 由于新插入这个值导致 size 已经超过了阈值，需要进行扩容

    if (++size > threshold)

        resize();

    afterNodeInsertion(evict);

    return null;

}

final Node<K,V>[] resize() {

    Node<K,V>[] oldTab = table;

    int oldCap = (oldTab == null) ? 0 : oldTab.length;

    int oldThr = threshold;

    int newCap, newThr = 0;

    if (oldCap > 0) { // 对应数组扩容

        if (oldCap >= MAXIMUM_CAPACITY) {

            threshold = Integer.MAX_VALUE;

            return oldTab;

        }

        // 将数组大小扩大一倍

        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&

                 oldCap >= DEFAULT_INITIAL_CAPACITY)

            // 将阈值扩大一倍

            newThr = oldThr << 1; // double threshold

    }

    else if (oldThr > 0) // 对应使用 new HashMap(int initialCapacity) 初始化后，第一次 put 的时候

        newCap = oldThr;

    else {// 对应使用 new HashMap() 初始化后，第一次 put 的时候

        newCap = DEFAULT_INITIAL_CAPACITY;

        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);

    }



    if (newThr == 0) {

        float ft = (float)newCap * loadFactor;

        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?

                  (int)ft : Integer.MAX_VALUE);

    }

    threshold = newThr;



    // 用新的数组大小初始化新的数组

    Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];

    table = newTab; // 如果是初始化数组，到这里就结束了，返回 newTab 即可



    if (oldTab != null) {

        // 开始遍历原数组，进行数据迁移。

        for (int j = 0; j < oldCap; ++j) {

            Node<K,V> e;

            if ((e = oldTab[j]) != null) {

                oldTab[j] = null;

                // 如果该数组位置上只有单个元素，那就简单了，简单迁移这个元素就可以了

                if (e.next == null)

                    newTab[e.hash & (newCap - 1)] = e;

                // 如果是红黑树，具体我们就不展开了

                else if (e instanceof TreeNode)

                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);

                else { 

                    // 这块是处理链表的情况，

                    // 需要将此链表拆成两个链表，放到新的数组中，并且保留原来的先后顺序

                    // loHead、loTail 对应一条链表，hiHead、hiTail 对应另一条链表，代码还是比较简单的

                    Node<K,V> loHead = null, loTail = null;

                    Node<K,V> hiHead = null, hiTail = null;

                    Node<K,V> next;

                    do {

                        next = e.next;

                        if ((e.hash & oldCap) == 0) {

                            if (loTail == null)

                                loHead = e;

                            else

                                loTail.next = e;

                            loTail = e;

                        }

                        else {

                            if (hiTail == null)

                                hiHead = e;

                            else

                                hiTail.next = e;

                            hiTail = e;

                        }

                    } while ((e = next) != null);

                    if (loTail != null) {

                        loTail.next = null;

                        // 第一条链表

                        newTab[j] = loHead;

                    }

                    if (hiTail != null) {

                        hiTail.next = null;

                        // 第二条链表的新的位置是 j + oldCap，这个很好理解

                        newTab[j + oldCap] = hiHead;

                    }

                }

            }

        }

    }

    return newTab;

}

public V get(Object key) {

    Node<K,V> e;

    return (e = getNode(hash(key), key)) == null ? null : e.value;

}

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;

}