ConcurrentHashMap源代码阅读笔记

ConcurrentHashMap源代码阅读笔记

---

提前准备

• 在计算机中,一个数字乘以2和右移一位是一个同样的操作,但是右移是一个很高效的操作.
• JDK中一个对象引用的存储大小是2的倍数字节.32位机中为4字节,64位机中为8字节.
• 对于数组的快速操作,可以使用Unsafe类类执行.通过对偏移量的操作来达到速度快速访问的效果

基础知识

由于在多线程并发的环境下,Hashmap会出现死循环的问题,而使用同步语义进行map操作则性能会很差,所以在这种情况下,使用专门为多线程环境并发环境设计的ConcurrentHashmap就是一种比较好的选择.ConcurrentHashmap采用一种称之为锁分离的设计方式.简单的说,Concurrenthashmap就是由多个自带 ReentrantLock的HashMap组成的.当不同的线程进行写操作的时候,如果可以分离在不同的Hashmap上,就可以实现写不干扰.但是在单个的Hashmap内,还是需要通过加锁来进行写不干扰的.而在读取操作中,通过Volatile关键字,保证读取到的值都是最新值.

构造方法

public ConcurrentHashMap(int initialCapacity,  float loadFactor, int concurrencyLevel) {
        if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)
            throw new IllegalArgumentException();
        if (concurrencyLevel > MAX_SEGMENTS)
            concurrencyLevel = MAX_SEGMENTS;
        // Find power-of-two sizes best matching arguments
        int sshift = 0;
        int ssize = 1;
        //根据并发数来确定segment的数量,保证(1)数量比并发数大,这样最好的情况就是每个线程都刚好使用不同的segmengt,不争用锁(2)数量是2的次方,这样确定index的时候效率比较高,可以使用并运算,这点和hashmap是一致的
       //ssize就是segment的个数,sshift就是次方数,也即是ssize这个数字所占的bit位数
        while (ssize < concurrencyLevel) {
            ++sshift;
            ssize <<= 1;
        }
        //一个int占据32个bit位数.那么一个值的hash值.它右移segmentShift,也就最高位的sshift位可以用来和segmentMask进行&运算,求出需要使用的segment下标
        this.segmentShift = 32 - sshift;
        //用来确定使用的segment的下标,这个数字的所占的bit个数就是sshift
        this.segmentMask = ssize - 1;
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        int c = initialCapacity / ssize;
        if (c * ssize < initialCapacity)
            ++c;
        int cap = MIN_SEGMENT_TABLE_CAPACITY;
        while (cap < c)
            cap <<= 1;
        //这步结束之后,确定了每一个segment的大小.大小是2的次方数,大于预计总容量除以线程数的结果
        // create segments and segments[0]
        Segment<K,V> s0 =
            new Segment<K,V>(loadFactor, (int)(cap * loadFactor),
                             (HashEntry<K,V>[])new HashEntry[cap]);
        Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize];
        UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]
        this.segments = ss;
    }

放入数据

在放入数据的时候,首先会通过一定的hash计算,来得到需要用哪个Hashmap.如果不同的线程使用不同的HashMap,就不会造成锁争用.下面来看代码.

public V putIfAbsent(K key, V value) {
        Segment<K,V> s;
        if (value == null)
            throw new NullPointerException();
        int hash = hash(key);
        //无符号左移,这样就可以使用hash值的高sshift位进行&运算,求出该值对应的segment下标
        int j = (hash >>> segmentShift) & segmentMask;
SSHIFT = 31 - Integer.numberOfLeadingZeros(ss);
       //这里的j<<SSHIFT是等于 j*ss.因为ss是2的倍数,而sshift是ss的bit位数
        if ((s = (Segment<K,V>)UNSAFE.getObject
             (segments, (j << SSHIFT) + SBASE)) == null)
         // 如果不存在,这里就对这个位置的hashmap进行初始化
            s = ensureSegment(j);
        return s.put(key, hash, value, true);
    }

这段写入的代码里涉及到几个点,首先是确定对应的HashMap也就是代码中的segment存在.如果不存在就进行初始化.初始化代码如下

private Segment<K,V> ensureSegment(int k) {
        final Segment<K,V>[] ss = this.segments;
        long u = (k << SSHIFT) + SBASE; // raw offset
        Segment<K,V> seg;
        if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u)) == null) {
            Segment<K,V> proto = ss[0]; // use segment 0 as prototype
            int cap = proto.table.length;
            float lf = proto.loadFactor;
            int threshold = (int)(cap * lf);
            HashEntry<K,V>[] tab = (HashEntry<K,V>[])new HashEntry[cap];
            if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))
                == null) { // recheck
                Segment<K,V> s = new Segment<K,V>(lf, threshold, tab);
                //这段初始化的代码没有采用锁,而是采用了更为高效的CAS方式来进行初始化的唯一确定.并且通过Volatile方式进行数值初始化完毕确认.
                while ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))
                       == null) {
                    if (UNSAFE.compareAndSwapObject(ss, u, null, seg = s))
                        break;
                }
            }
        }
        return seg;
    }

在初始化完成之后,开始执行真正的写入动作.
执行真正的写入动作时,会尝试获取锁.如果没有立刻获取到,则会尝试.并且在尝试期间进行一些额外操作以提高效率.先看尝试的代码

private HashEntry<K,V> scanAndLockForPut(K key, int hash, V value) {
            HashEntry<K,V> first = entryForHash(this, hash);
            HashEntry<K,V> e = first;
            HashEntry<K,V> node = null;
            int retries = -1; // negative while locating node
            while (!tryLock()) {
                HashEntry<K,V> f; // to recheck first below
                if (retries < 0) {
                    //如果头结点为空，则先创建一个节点在这里准备着后面可能会有用。
                    //如果头结点不为空，则意味着后，后续真正插入的时候有可能key是相同的，这里就不要提前做生成node的动作，减少浪费
                    if (e == null) {
                        if (node == null) // speculatively create node

                            node = new HashEntry<K,V>(hash, key, value, null);
                        retries = 0;
                    }
                    else if (key.equals(e.key))
                        retries = 0;
                    else
                        e = e.next;
                }
                else if (++retries > MAX_SCAN_RETRIES) {
                    lock();
                    break;
                }
                //每偶数次的时候检查下是否头结点变化了，来确定是否有新的节点被插入，开始重新尝试
                else if ((retries & 1) == 0 &&
                         (f = entryForHash(this, hash)) != first) {
                    e = first = f; // re-traverse if entry changed
                    retries = -1;
                }
            }
            return node;
        } 

获取到锁之后,进行写入操作.写入代码如下

inal V put(K key, int hash, V value, boolean onlyIfAbsent) {
            //如果直接获取到了锁，就返回。否则的话，就尝试在没有获取到锁的这段时间执行一些操作.执行的操作是,在没有获得锁的这段时间,如果发现该节点上没有一个Entry,就先新建一个node,这样后面的话,就可以节省掉这段新建的时间
            HashEntry<K,V> node = tryLock() ? null :
                scanAndLockForPut(key, hash, value);
            V oldValue;
            try {
                HashEntry<K,V>[] tab = table;
                int index = (tab.length - 1) & hash;
                HashEntry<K,V> first = entryAt(tab, index);
                for (HashEntry<K,V> e = first;;) {
                 //寻找是否有相同的key
                    if (e != null) {
                        K k;
                        if ((k = e.key) == key ||
                            (e.hash == hash && key.equals(k))) {
                            oldValue = e.value;
                            if (!onlyIfAbsent) {
                                e.value = value;
                                ++modCount;
                            }
                            break;
                        }
                        e = e.next;
                    }
                    else {
                       //下面这里,first是空的
                        if (node != null)
                            node.setNext(first);
                        else
                          //创建node,
                            node = new HashEntry<K,V>(hash, key, value, first);
                        int c = count + 1;
                        if (c > threshold && tab.length < MAXIMUM_CAPACITY)
                          //进行hashmap扩容
                            rehash(node);
                        else
                     //这里进行插入的时候使用了一个小技巧。因为在锁退出的时候，锁区域内的volatie数据都会刷新，所以这里的写入使用了下面的代码
                   //
                   UNSAFE.putOrderedObject(tab, ((long)i << TSHIFT) + TBASE, e);
                  //这是为了进一步的提升性能，这个方法可以不插入storeLoad屏障
                            setEntryAt(tab, index, node);
                        ++modCount;
                        count = c;
                        oldValue = null;
                        break;
                    }
                }
            } finally {
                unlock();
            }
            return oldValue;
        }

如果写入的过程发现需要扩容,此时的代码如下.注意,在扩容的时候已经获取到了锁.

private void rehash(HashEntry<K,V> node) {
            HashEntry<K,V>[] oldTable = table;
            int oldCapacity = oldTable.length;
            int newCapacity = oldCapacity << 1;
            threshold = (int)(newCapacity * loadFactor);
            HashEntry<K,V>[] newTable =  (HashEntry<K,V>[]) new HashEntry[newCapacity];
            int sizeMask = newCapacity - 1;
            for (int i = 0; i < oldCapacity ; i++) {
                HashEntry<K,V> e = oldTable[i];
                if (e != null) {
                    HashEntry<K,V> next = e.next;
                    int idx = e.hash & sizeMask;
                    if (next == null)   //  Single node on list
                        newTable[idx] = e;
                    else { // Reuse consecutive sequence at same slot
                        HashEntry<K,V> lastRun = e;
                        int lastIdx = idx;
                        //下面的这段代码会寻找到原来的这个entry链中最后一个新摆放位置不同的元素.也就是说从这个元素开始,该元素后面的元素的摆放值计算结果不变,也就是下面的k不变.
                        for (HashEntry<K,V> last = next;
                             last != null;
                             last = last.next) {
                            int k = last.hash & sizeMask;
                            if (k != lastIdx) {
                                lastIdx = k;
                                lastRun = last;
                            }
                        }
                        //把lastrun放在这里,lastrun后面跟着的元素也就到了这里,而first到lastrun之间的元素就需要再次计算和摆放
                        newTable[lastIdx] = lastRun;
                        // Clone remaining nodes
                        //这样的摆放相当于将原来的顺序倒过来
                        for (HashEntry<K,V> p = e; p != lastRun; p = p.next) {
                            V v = p.value;
                            int h = p.hash;
                            int k = h & sizeMask;
                            HashEntry<K,V> n = newTable[k];
                            newTable[k] = new HashEntry<K,V>(h, p.key, v, n);
                        }
                    }
                }
            }
            int nodeIndex = node.hash & sizeMask; // add the new node
            node.setNext(newTable[nodeIndex]);
            newTable[nodeIndex] = node;
            table = newTable;
        }

这样,在一个HashMap上的写入操作就完毕了.至于像remove这种,就是纯粹设定值的操作就没什么好说的了.而至于像get这种读取操作,因为都使用volatile修饰符进行修饰,所以读取的时候就都能读取到最新的值.
之前说的都是针对单个HashMap的操作.那如果是全局计算Size这样的操作.该如何进行的.其实思路也很简单,首先是通过两次不加锁的全局遍历,获取每个Map的count值相加结果和modCount值相加结果.如果一致的话,就意味着在这两次遍历中,没有对map进行写操作,就将结果返回.否则就对所有的map执行加锁操作,代码如下

public int size() {
        // Try a few times to get accurate count. On failure due to
        // continuous async changes in table, resort to locking.
        final Segment<K,V>[] segments = this.segments;
        int size;
        boolean overflow; // true if size overflows 32 bits
        long sum;         // sum of modCounts
        long last = 0L;   // previous sum
        int retries = -1; // first iteration isn't retry
        try {
            for (;;) {
                if (retries++ == RETRIES_BEFORE_LOCK) {
                    for (int j = 0; j < segments.length; ++j)
                        ensureSegment(j).lock(); // force creation
                }
                sum = 0L;
                size = 0;
                overflow = false;
                for (int j = 0; j < segments.length; ++j) {
                    Segment<K,V> seg = segmentAt(segments, j);
                    if (seg != null) {
                        sum += seg.modCount;
                        int c = seg.count;
                        if (c < 0 || (size += c) < 0)
                            overflow = true;
                    }
                }
                if (sum == last)
                    break;
                last = sum;
            }
        } finally {
            if (retries > RETRIES_BEFORE_LOCK) {
                for (int j = 0; j < segments.length; ++j)
                    segmentAt(segments, j).unlock();
            }
        }
        return overflow ? Integer.MAX_VALUE : size;
    }

上面已经讲述了作为map的大部分操作。
下面来讲下对Itetator的支持。
初始化的方法如下
在初始化之中，所以的index数值全都直接指向了当前的最大值，这样在遍历的时候有个好处，就是只要index小于0了。就意味着遍历已经结束了。
advance这个方法很重要，这个方法是进行下一个非空entry的获取方法。

 abstract class HashIterator {
        int nextSegmentIndex;
        int nextTableIndex;
        HashEntry<K,V>[] currentTable;
        HashEntry<K, V> nextEntry;
        HashEntry<K, V> lastReturned;
        HashIterator() {
            nextSegmentIndex = segments.length - 1;
            nextTableIndex = -1;
            advance();
        }
        /**
         * Set nextEntry to first node of next non-empty table
         * (in backwards order, to simplify checks).
         */
        // 首先尝试对能获得的非空segment进行定位，定位后，对该segment进行非空entry进行定位。非空定位时，是倒序进行的。
        final void advance() {
            for (;;) {
                if (nextTableIndex >= 0) {
                    if ((nextEntry = entryAt(currentTable,
                                             nextTableIndex--)) != null)
                        break;
                }
                else if (nextSegmentIndex >= 0) {
                    Segment<K,V> seg = segmentAt(segments, nextSegmentIndex--);
                    if (seg != null && (currentTable = seg.table) != null)
                        nextTableIndex = currentTable.length - 1;
                }
                else
                    break;
            }
        }