摘要：關(guān)于不安全的問(wèn)題，感興趣的可以去看一下這篇文章老生常談，的死循環(huán)。

廢話不多說(shuō)，直接進(jìn)入主題：

    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);
        // 初始化加載因子（默認(rèn)0.75f）
        this.loadFactor = loadFactor;
        // 初始化容器大小（默認(rèn)16）
        threshold = initialCapacity;
        init();
    }
    // 可以看到j(luò)dk1.7中hashMap的init方法并沒(méi)有創(chuàng)建hashMap的數(shù)組和Entry，
    // 而是移到了put方法里，后邊會(huì)講到
    void init() {
    }

    public V put(K key, V value) {
        // 可以看到，初始化table是在首次put時(shí)開(kāi)始的
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);
        }
        // 對(duì)key為`null`的處理，進(jìn)入到方法里可以看到直接將其hash置為0,并插入到了數(shù)組下標(biāo)為0的位置
        if (key == null)
            return putForNullKey(value);
        // 計(jì)算hash值
        int hash = hash(key);
        // 根據(jù)hash，查找到數(shù)組對(duì)應(yīng)的下標(biāo)
        int i = indexFor(hash, table.length);
        // 遍歷數(shù)組第i個(gè)位置的鏈表
        for (Entry e = table[i]; e != null; e = e.next) {
            Object k;
            // 找到相同的key，并覆蓋其value
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
    
        modCount++;
        // 在table[i]下的鏈表中沒(méi)有找到相同的key，將entry加入到此鏈表
        // addEntry方法后邊會(huì)再看一下
        addEntry(hash, key, value, i);
        return null;
    }

    // 容量一定為2的n次方，比如設(shè)置size=10，則容量則為大于10的且為2的n次方=16
    // Find a power of 2 >= toSize
    int capacity = roundUpToPowerOf2(toSize);
    
    // 計(jì)算擴(kuò)容臨界值：capacity * loadFactor，當(dāng)size>=threshold時(shí)，觸發(fā)擴(kuò)容
    threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
    // 初始化Entry數(shù)組
    table = new Entry[capacity];
    initHashSeedAsNeeded(capacity);

能進(jìn)入到addEntry方法，說(shuō)明根據(jù)hash值計(jì)算出的數(shù)組下標(biāo)沖突，但是key不一樣

    void addEntry(int hash, K key, V value, int bucketIndex) {
        // 當(dāng)數(shù)組的size >= 擴(kuò)容閾值，觸發(fā)擴(kuò)容，size大小會(huì)在createEnty和removeEntry的時(shí)候改變
        if ((size >= threshold) && (null != table[bucketIndex])) {
            // 擴(kuò)容到2倍大小，后邊會(huì)跟進(jìn)這個(gè)方法
            resize(2 * table.length);
            // 擴(kuò)容后重新計(jì)算hash和index
            hash = (null != key) ? hash(key) : 0;
            bucketIndex = indexFor(hash, table.length);
        }
        // 創(chuàng)建一個(gè)新的鏈表節(jié)點(diǎn)，點(diǎn)進(jìn)去可以了解到是將新節(jié)點(diǎn)添加到了鏈表的頭部
        createEntry(hash, key, value, bucketIndex);
    }

    void resize(int newCapacity) {
        Entry[] oldTable = table;
        int oldCapacity = oldTable.length;
        if (oldCapacity == MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return;
        }
        // 創(chuàng)建2倍大小的新數(shù)組
        Entry[] newTable = new Entry[newCapacity];
        // 將舊數(shù)組的鏈表轉(zhuǎn)移到新數(shù)組，就是這個(gè)方法導(dǎo)致的hashMap不安全，等下我們進(jìn)去看一眼
        transfer(newTable, initHashSeedAsNeeded(newCapacity));
        table = newTable;
        // 重新計(jì)算擴(kuò)容閾值(容量*加載因子)
        threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
    }

對(duì)于put方法，get方法就很簡(jiǎn)單了

    public V get(Object key) {
        if (key == null)
            return getForNullKey();
        Entry entry = getEntry(key);

        return null == entry ? null : entry.getValue();
    }
    final Entry getEntry(Object key) {
        if (size == 0) {
            return null;
        }
        int hash = (key == null) ? 0 : hash(key);
        // 根據(jù)hash值找到對(duì)應(yīng)的數(shù)組下標(biāo)，并遍歷其E
        for (Entry 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;
    }

    void transfer(Entry[] newTable, boolean rehash) {
        int newCapacity = newTable.length;
        // 遍歷舊數(shù)組
        for (Entry e : table) {
            // 遍歷鏈表
            while(null != e) {
                Entry next = e.next;
                if (rehash) {
                    e.hash = null == e.key ? 0 : hash(e.key);
                }
                // 計(jì)算節(jié)點(diǎn)在新數(shù)組中的下標(biāo)
                int i = indexFor(e.hash, newCapacity);
                // 將舊節(jié)點(diǎn)插入到新節(jié)點(diǎn)的頭部
                e.next = newTable[i];
                newTable[i] = e;
                e = next;
            }
        }
    }

從上面的代碼可以看出，從oldTable中遍歷Entry是正序的，也就是a->b->c的順序，而插入到新數(shù)組的時(shí)候是采用的頭插法，也就是后插入的在首部，所以遍歷之后結(jié)果為c->b->a;

此時(shí)正常邏輯是沒(méi)有問(wèn)題的，而當(dāng)有多個(gè)線程同時(shí)進(jìn)行擴(kuò)容操作時(shí)就出現(xiàn)問(wèn)題了，看下邊的圖

此時(shí)的狀態(tài)為a線程創(chuàng)建了新數(shù)組，b線程也創(chuàng)建了新數(shù)組，同時(shí)b的cpu時(shí)間片用完進(jìn)入等待階段，

此時(shí)的狀態(tài)為a線程完成了數(shù)組的擴(kuò)容，退出了transfer方法，但是還沒(méi)有執(zhí)行下一句table = newTable;

b線程回來(lái)繼續(xù)執(zhí)行代碼

Entry next = e.next;
int i = indexFor(e.hash, newCapacity);
e.next = newTable[i];
newTable[i] = e;
e = next;

結(jié)果如下：

b會(huì)繼續(xù)執(zhí)行循環(huán)代碼，進(jìn)入到死循環(huán)狀態(tài)。

關(guān)于transfer不安全的問(wèn)題，感興趣的可以去看一下這篇文章老生常談，HashMap的死循環(huán)。