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()：

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關鍵字更輕量級的同步機制。