HashMap以及ConcurrentHashMap（volatile）

1.HashMap怎麼實現hashcode和equals

HashMap的數據結構是鏈表+數組，HashMap的數據結構相似於：

元素0->[hashCode=0,key.value=x1的數據]
元素1->[hashCode=1,key.value=y1的數據]
...
元素n->[hashCode=n,key.value=n1的數據]複製代碼

hashMap的put和get方法都會調用hashCode方法，若是兩個hashCode有衝突，再調用equals方法:

put()：會調用對象的hashCode()方法來計算hashcode，而後找到buchet（桶）位置來儲存對象，當獲取對象時，經過鍵對象的equals()方法找到正確的鍵值對，而後返回值對象。hashMap經過鏈表來解決衝突問題，若是發生碰撞，對象就會儲存在鏈表的下一節點。

get()：buchet（桶）裏的第一個節點，直接命中；若是有衝突，則經過key.equals(k)去找對應的能夠。

爲何要重寫hashCode()和equals()：

首先先來看一下equals:

public boolean equals(Object obj){
    return (this==obj);
}複製代碼

是經過==來比較兩個對象的引用地址，Object的equals只是簡單的判斷是否是同一個實例，但若是咱們須要比較邏輯上的相等，就須要重寫equals()方法，而涉及到HashMap的時候，重寫了equals()就須要重寫hashCode()方法。

2.concurrentHashMap怎麼實現

採用了「分段鎖」的方式來確保線性安全，相比於HashTable，不會存在鎖競爭，能夠有效的提升併發效率。

concurrentHashMap的主幹是Segment數組

final Segment<K,V>[] segment;複製代碼

Segment繼承了ReentrantLock，因此它就是一種「可重入鎖」。在concurrentHashMap中一個Segment就至關於一個子哈希表，Segment裏維護了一個HashEntry數組，在併發狀況下，不須要考慮鎖的競爭。

#Segment:
transient volatile HashEntry<K,V>[] table;複製代碼

一個ConcurrentHashMap維護一個Segment，一個Segment維護一個HashEntry，對於同一個Segment才考慮線程同步，不一樣Segment不須要考慮。

jdk7中：

put()：1.定位segment並確保定位的Segment已初始化 2.調用Segment的put方法

get()：get無需加鎖，因爲其涉及的共享變量都使用volatile修飾，volatile能夠保證內存可見性，因此不會讀取過時數據。

jdk8中：

put()：沿用了hashMap中的put，根據hash值計算這個新插入的點在table中的位置i，若是i位置是空的，直接放進去，不然進行判斷，若是i位置是樹節點，按照樹的方式插入新的節點，不然把i插入到鏈表的末尾，可是不容許key或value爲null。

調用的是putVal方法

public V put(K key, V value) {    return putVal(key, value, false);}複製代碼

final V putVal(K key, V value, boolean onlyIfAbsent) {
    if (key == null || value == null) throw new NullPointerException();
    int hash = spread(key.hashCode());// 計算key的hash值
    int binCount = 0;// 表示table中索引下標表明的鏈表或紅黑樹中的節點數量
    // 採用自旋方式，等待table第一次put初始化完成，或等待鎖或等待擴容成功而後再插入
    for (Node<K,V>[] tab = table;;) {
        // f節點標識table中的索引節點，多是鏈表的head，也多是紅黑樹的head
        // n:table的長度，i:插入元素在table的索引下標，fh : head節點的hash值
        Node<K,V> f; int n, i, fh;
        if (tab == null || (n = tab.length) == 0)// 第一次插入元素，先執行初始化
            tab = initTable();
        // 定位到的索引下標節點(head)爲null，表示第一次在此索引插入，
        // 不加鎖直接插入在head以後，在casTabAt中採用Unsafe的CAS操做，保證線程安全
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value, null)))
                break;                   // no lock when adding to empty bin
        }
        // head節點爲ForwadingNode類型節點，表示table正在擴容，鏈表或紅黑樹也加入到幫助擴容操做中
        else if ((fh = f.hash) == MOVED) 
            tab = helpTransfer(tab, f);
        else {// 索引下標存在元素，且爲普通Node節點，給head加鎖後執行插入或更新
            V oldVal = null;
            synchronized (f) {
                if (tabAt(tab, i) == f) {
                    if (fh >= 0) {// 爲普通鏈表節點，還記得以前定義的幾種常量Hash值嗎？
                        binCount = 1;
                        for (Node<K,V> e = f;; ++binCount) {
                            K ek;
                            if (e.hash == hash && ((ek = e.key) == key || (ek != null && key.equals(ek)))) {
                                oldVal = e.val;
                                if (!onlyIfAbsent)
                                    e.val = value;
                                break;
                            }
                            Node<K,V> pred = e;
                            // 插入新元素，每次插在單向鏈表的末尾，這點與Java7中不一樣（插在首部）
                            if ((e = e.next) == null) {
                                pred.next = new Node<K,V>(hash, key, value, null);
                                break;
                            }
                        }
                    }
                    else if (f instanceof TreeBin) {// head爲樹節點，按樹的方式插入節點
                        Node<K,V> p;
                        binCount = 2;
                        if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key, value)) != null) {
                            oldVal = p.val;
                            if (!onlyIfAbsent)
                                p.val = value;
                        }
                    }
                }
            }
            // 鏈表節點樹超過閾值8，將鏈表轉換爲紅黑樹結構
            if (binCount != 0) {
                if (binCount >= TREEIFY_THRESHOLD)
                    treeifyBin(tab, i);
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    // 若是是插入新元素，則將鏈表或紅黑樹最新的節點數量加入到CounterCells中
    addCount(1L, binCount);
    return null;
}複製代碼

get()：

一、計算key的hash值，並定位table索引
二、若table索引下元素(head節點)爲普通鏈表，則按鏈表的形式迭代遍歷。
三、若table索引下元素爲紅黑樹TreeBin節點，則按紅黑樹的方式查找(find方法)。

public V get(Object key) {
    Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
    int h = spread(key.hashCode());
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (e = tabAt(tab, (n - 1) & h)) != null) {
        if ((eh = e.hash) == h) {// 普通鏈表
            if ((ek = e.key) == key || (ek != null && key.equals(ek)))
                return e.val;
        }
        // hash值小於-1,即爲紅黑樹，還記得以前定義的TreeBin節點的hash值嗎
        else if (eh < 0)
            return (p = e.find(h, key)) != null ? p.val : null;
        while ((e = e.next) != null) {// 匹配下一個鏈表元素
            if (e.hash == h &&
                ((ek = e.key) == key || (ek != null && key.equals(ek))))
                return e.val;
        }
    }
    return null;
}複製代碼

3.volatile

volatile實現的是可見性，即一個線程的修改對另外一個線程是可見的。也就是一個線程修改結果，另外一個線程立刻能看到。

當把變量聲明爲volatile類型後，編譯器與運行時都會注意到這個變量是共享的，所以不會將該變量上的操做與其餘內存操做一塊兒重排序，在訪問volatile變量時不會執行加鎖操做，所以也就不會使執行線程阻塞，所以volatile變量是一種比sychronized關鍵字更輕量級的同步機制。