jdk1.7 HashMap部分源码分析和扩容循环链表分析

众所周知啊，jdk1.7的版本当HashMap扩容的时候，是有可能发生循环链表的情况，我们今天就来探究探究他究竟是如何产生的
分析之前，我们先来理清楚几个概念
HashMap 1.7采用的数组加链表的形式, 建议读者阅读此文章要有一点hashmap的基本知识
我们先来复习一下 jdk1.7 HashMap的相关方法的源码
先从put方法开始分析

public V put(K key, V value) {
		// 懒加载 第一次put的时候发现Entry数组是空的 然后去初始化
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);
        }
        // put key 为 null 的特殊情况
        if (key == null)
            return putForNullKey(value);
        // 计算key的hash值
        int hash = hash(key);
        // 计算key的桶下标
        int i = indexFor(hash, table.length);
        // 遍历对应桶下的链表
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            // 如果hash值相等 并且 如果key是相同对象 或者 equals方法返回true
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            	// 下面就是设置新的value 并且把旧的value返回
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }

        modCount++;
        // 如果没有相同的节点 则代表这次是新的一个节点，指向添加节点的方法
        addEntry(hash, key, value, i);
        return null;
    }

我们来看看他是如何添加节点的

void addEntry(int hash, K key, V value, int bucketIndex) {
		// 判断当前节点的个数有没有达到扩容的的标准 并且当前bucketIndex下标的hash桶不为null
        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);
    }

我们先把添加节点的方法看完，在看扩容

void createEntry(int hash, K key, V value, int bucketIndex) {
		// 获得对应的hash桶
        Entry<K,V> e = table[bucketIndex];
        // 直接头插法
        table[bucketIndex] = new Entry<>(hash, key, value, e);
        // 节点个数加一
        size++;
    }

由上可知 ， jdk1.7 hashmap添加节点 是 采用头插法

然后我们再来看看他是如何扩容的
调用这个方法resize(2 * table.length) 把当前桶的长度 乘 2 传入

void resize(int newCapacity) {
		// 获得旧hash桶
        Entry[] oldTable = table;
        int oldCapacity = oldTable.length;
        // 判断是否达到最大容量
        if (oldCapacity == MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return;
        }
		// 产生长度为之前的两倍的hash桶
        Entry[] newTable = new Entry[newCapacity];
        // 把旧的数据copy到新的hash桶里面
        transfer(newTable, initHashSeedAsNeeded(newCapacity));
        // 将新table赋值给table变量
        table = newTable;
        // 机算下一次扩容的阈值
        threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
    }

我们进入transfer方法

void transfer(Entry[] newTable, boolean rehash) {
        int newCapacity = newTable.length;
        // 遍历旧hash桶
        for (Entry<K,V> e : table) {
        	// 遍历链表
            while(null != e) {
            	// 获得next节点
                Entry<K,V> next = e.next;
                // 默认false
                if (rehash) {
                    e.hash = null == e.key ? 0 : hash(e.key);
                }
                // 机算新的下标
                int i = indexFor(e.hash, newCapacity);
                // 下面两步 直接头插法进新的hash桶 
                e.next = newTable[i];
                newTable[i] = e;
                e = next;
            }
        }
    }

以上，我们就把 添加节点和扩容分析完成
下面我们来分析扩容变成循环链表的情况吧
先上测试代码:

static void testJDK7HashMapError() {
        final HashMap<Integer, Integer> map = new HashMap<>(16);
        map.put(2, null);
        map.put(32, null);
        map.put(70, null);
        map.put(5, null);
        map.put(6, null);
        map.put(7, null);
        map.put(8, null);
        map.put(9, null);
        map.put(10, null);
        map.put(11, null);
        map.put(12, null);
        map.put(13, null);
        new Thread(new Runnable() {
            @Override
            public void run() {
                map.put(14, null);
            }
        }, "test-thread1").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                map.put(15, null);
            }
        },"test-thread2").start();
    }

代码就是 初始化一个初始hash桶容量16的hashmap，16 * 0.75 = 12，前面刚好有12和数据
所以此时 开启两个线程同时去put，都会触发扩容，我们让第一个线程完成扩容，让第二个线程停在transfer 方法的 **if (rehash)**这条判断，也就是模拟两个线程去put数据触发扩容，第一个线程扩容成功，第二个线程到这条代码，刚好让出了cpu，而第一个线程扩容完成之后，第二个线程又获得到cpu的调读。
我们此次扩容，只专注hash桶下标为2的链表
先看下未扩容之前的链表

也就是 70->32->2->null 对应的是key的值
先在相应的地方打上断点

debug运行，然后先放行test-thread1线程
然后就会到test-thread2线程此刻打断点的地方
我们看一下扩容后下标为2的hash桶

也就是 2->32->70->null
在这里先介绍一下他的头插法的步骤
他是先把当前这个节点的 next 指向对应的hash桶的第一个节点，然后hash桶直接指向这个节点，于是就完成了头插法。
此时 test-thread2获得了cpu的调度，然后继续扩容，但是他遍历已经是新的Entry数组了，我们主要关注此刻他在遍历hash桶为2的链表
此刻 e的key是70 next的key是32，这是因为之前扩容扩到这里，然后现在重新获得到cpu的调度继续扩容
然后将 此刻的e 头插法到下标为1的newTable的hash桶内，
然后e = key为32的节点 然后又因为新的table内，key为32的节点的next已经是70了，所以这边获得到的next又是70的那个节点
然后再次头插法到下标为1的newTable的hash桶内，然后e 又变成key为70的节点，此时的next就为null了，然后此时 又将70头插法到下标为1的newTable的hash桶内
经过上面的扩容后 这个线程的newTable就已经发生了循环链表了

从上图也能看出来，出现了循环链表
然后会将这个newtable 赋值给 当前这个map的table
此时 再去get的话 并且那个key不存在 然后他的key 也是这个hash桶的话
就会出现死循环
虽然 jdk8 解决了链表死循环的问题，但是在并发的情况下，依旧是线程不安全的。

后面我可能会介绍jdk8的 ConcurrentHashMap 一种线程安全的map容器