ConcurrentHashMap源码分析

本篇博客的目录：

一：put方法源码

二：get方法源码

三：rehash的过程

四：总结

一：put方法的源码

首先，我们来看一下segment内部类中put方法的源码，这个方法它是segment片组的，也就是我们在用concurrentHash的put方法的时候，实际上它会取得key的hashcode值，再计算它的hash，然后它会选择一个片组，进入segment中的这个方法。所以我们根本上要看的是这个方法：

public V put(K key, V value) {
       if (value == null)
           throw new NullPointerException();
       int hash = hash(key.hashCode());
       return segmentFor(hash).put(key, hash, value, false);
   }

从这里也可以看出concurrentHashMap不允许值为null，否则会抛出NullPointetException.
复制代码

    V put(K key, int hash, V value, boolean onlyIfAbsent) {
        lock();
        try {
            int c = count;
            if (c++ > threshold) // ensure capacity
                rehash();
            HashEntry<K,V>[] tab = table;
            int index = hash & (tab.length - 1);
            HashEntry<K,V> first = tab[index];
            HashEntry<K,V> e = first;
            while (e != null && (e.hash != hash || !key.equals(e.key)))
                e = e.next;

            V oldValue;
            if (e != null) {
                oldValue = e.value;
                if (!onlyIfAbsent)
                    e.value = value;
            }
            else {
                oldValue = null;
                ++modCount;
                tab[index] = new HashEntry<K,V>(key, hash, first, value);
                count = c; // write-volatile
            }
            return oldValue;
        } finally {
            unlock();
        }
    }

复制代码

调用put方法之后，它首先是lock()上锁，防止多个线程同时put，可能会有并发的问题。上锁的话可以保证每次put一个key的时候，其他线程将会无法进入这个片组，它会去选择另外一个segment，这就是分段的 好处。并不简单粗暴的采用synchronized的方法阻塞其他线程。接下来是取它的元素多少，给它+1(只添加一个元素)每次新加元素的时候都要去判断它是否超过了数组的扩容临界值，如果超过了，就要对它进行扩容操作，也就是reHash，或者叫做"Hash再置"的过程。这里我们先略过，暂且不分析。往下走，接下来是取得它内部的table数组，就是封装键值对的数组，根据传入的hash值和数组的长度减去1进行与运算，找到一个预放置数组的位置，然后再找它对应的数组元素，再通过一个while循环去遍历这个节点上的链表，去寻找这个元素，如果找到这个元素了(证明欲放入的元素已存在)。然后取得它的值，判断onlyifAbsent,这个字段按照字面意思翻译为：是否缺席，也就是说放入一个元素前用这个字段是决定它是否存在，上面的 方法传入的参数为fasle,也就是它存在。那么就取它的值赋值给这个元素(替换它的值)。如果它不存在，增加修改次数，然后在这个位置上新new一个元素放进去，并把加+1的值赋给count，最后再返回旧值。最后在finally里进行解锁。以下是图示：

二：get方法的源码分析

get方法需要传入一个key和hash。它的原理同样等同于上面讲的put方法：

   public V get(Object key) {//根据key获取value
        int hash = hash(key.hashCode());//拿到键的hash值
        return segmentFor(hash).get(key, hash);//调用segmentFor方法传入key和hash值得到value
    }

通过key的hashcode值，传入segment中的get方法：
复制代码

 V get(Object key, int hash) {  //根据指定的key和hash值获取value值
            if (count != 0) { // 如果count不为0
                HashEntry<K,V> e = getFirst(hash);//根据传入的hash获取链表中的第一个键值对
                while (e != null) {//如果这个键值对不为null
                    if (e.hash == hash && key.equals(e.key)) {//如果该键值对的hash值等于方法传入的Hash，并且该键与第一个Hashentry对象通过equals方法比较相同
                        V v = e.value;//取第一个hashEntry对象的值
                        if (v != null)//如果该值不为null
                            return v;//返回值
                        return readValueUnderLock(e); // 调用readValueUnderLock方法返回对象的值
                    }
                    e = e.next;//指向下一个键值对，这里相当于去遍历整个链表，直到找到key对应的值
                }
            }
            return null;//如果找不到,返回null
        }

复制代码

get方法首先判断的是数组中的元素是不是0，如果不是0继续往下走，然后通过传入的hash值去获取他的第一个元素，如果这个元素不为null，说明可以找到这个hash对应的元素。否则就返回null。然后通过while循环再去判断hash值是否相同，key是否相同，在两者相同的情况下，获取该元素的value。如果这个value不为null，就返回这个值。如果它为null，调用readValueUnderLock()方法，这里主要是考虑到一点，如果再它取值的过程中，如果这个值正在被put进去。再来看看readValueUnderLock方法：
复制代码

 V readValueUnderLock(HashEntry<K,V> e) {//在锁中读取指定的HashEntry值
            lock();//上锁
            try {
                return e.value;//返回Hashentry中的value
            } finally {
                unlock();//解锁
            }
        }

复制代码

这里专门做了一个上锁的过程，主要是为了防止获取值的过程这个值正在被添加，此刻就会对取值进行上锁，那么put方法就会被阻塞，只得等它get完毕再put，那么又会有一个新的问题产生：比如假如一个线程现在要put一个键值对：put(“a”,“sunday”)，而map里面已经存在一个“a”,“Monday”;而另外一个线程正在get(“a”),此时得到的值是null还是“sunday”，还是monday?回答这个问题，只需要看这里transient volatile HashEntry<K,V>[] table;table是volatile的，所以它可以及时的同步它的Hashentry，它可以保证取到最后一次put的值。

三：rehash的过程

rehash的过程就是扩容的过程，每次要put一个值的时候，都要调用这个方法给当前的容量+1去检查是不是超过最大容量。我们来看一下它的源码，分析一下这个过程：
复制代码

 void rehash() 
            HashEntry<K,V>[] oldTable = table; //取当前的数组设为旧数组
            int oldCapacity = oldTable.length;//取旧数组的数组的长度
            if (oldCapacity >= MAXIMUM_CAPACITY)//判断旧数组的容量是否大于最大容量(保证当前的数组不越界)
                return;//如果是 结束
            HashEntry<K,V>[] newTable = HashEntry.newArray(oldCapacity<<1);//以旧数组的长度的2倍创建一个新数组
            threshold = (int)(newTable.length * loadFactor);//设置临界值为新数组的长度乘以加载因子
            int sizeMask = newTable.length - 1;//设置大小的掩码为新数组的长度减去1
            for (int i = 0; i < oldCapacity ; i++) {//遍历旧数组，也就是复制数组的过程
                // We need to guarantee that any existing reads of old Map can
                //  proceed. So we cannot yet null out each bin.
                HashEntry<K,V> e = oldTable[i];//取数组的元素

            if (e != null) {//如果不为null
                HashEntry<K,V> next = e.next;//往下遍历该节点上的链表
                int idx = e.hash & sizeMask;//用该节点的hash乘以大小的掩码获取一个位置值

                //  Single node on list
                if (next == null)//如果该节点上没有形成链表
                    newTable[idx] = e;//把新该元素的值设为新数组的计算出来的位置的值
                else { //如果该节点有连续的链表
                    // Reuse trailing consecutive sequence at same slot
                    HashEntry<K,V> lastRun = e;//取该节点
                    int lastIdx = idx;//取计算出来的位置
                    for (HashEntry<K,V> last = next;
                         last != null;
                         last = last.next) {//遍历该链表
                        int k = last.hash & sizeMask;//通过该元素的hash值与size掩码进行与运算出来一个位置值
                        if (k != lastIdx) {//如果两个值不相同
                            lastIdx = k;//把k的值赋值给lastIdx
                            lastRun = last;//把当前值设为lastRun的值
                        }
                    }
                    newTable[lastIdx] = lastRun;//用得出的值赋值给新数组

                    // Clone all remaining nodes
                    for (HashEntry<K,V> p = e; p != lastRun; p = p.next) {//遍历循环该链表中的元素
                        int k = p.hash & sizeMask;//取元素的hash值与size掩码进行与运算计算出它的位置
                        HashEntry<K,V> n = newTable[k];//取计算出来的位置元素的值
                        newTable[k] = new HashEntry<K,V>(p.key, p.hash,
                                                         n, p.value);//调用HashEntry的构造方法新建一个新HashEntry对象
                    }
                }
            }
        }
        table = newTable;//把新数组设定为片组维持的table
    }

复制代码

上面这个方法主要是对数组扩容的过程做一个简单的分析，根据代码可以发现以下几点问题：

1：数组扩容的时候是把原数组的长度*2(左移1位)

2：然后去遍历旧数组，这里分为两种情况，旧数组的节点存在链表和不存在链表，如果不存在链表，会把当前节点的hash与它的index进行与运算得出一个位置，然后把它放入到新素组的该位置

3：如果存在链表：会遍历当前的链表，然后把旧数组的当前值设为新数组计算出来的值后，再遍历该链表，把链表里面的值的key和value还有index位置新构建一个元素放入到新数组中

4:最后再把这个新数组代替原来的数组，让segment维护这个新数组