ConcurrentHashMap源码浅析

前两篇文件对ReentrantLock、CAS做了简单的介绍，现在开始分析下作为线程安全的集合ConcurrentHashMap是如何保证线程安全的，内容均为个人理解，如有理解有误的地方也请看到的大神指出，进入正题。

结构

ConcurrentHashMap的结构是Segment数组，Segment可以理解为片段、槽，而每个Segment里边是一个数组加链表的结构与HashMap一样，如何保证线程安全的呢，实际上是Segment继承ReentrantLock重入锁的机制保证线程安全的，下图是ConcurrentHashMap的结构

常量

static final int DEFAULT_INITIAL_CAPACITY = 16; ：默认初始大小
static final float DEFAULT_LOAD_FACTOR = 0.75f; ：负载因子
static final int DEFAULT_CONCURRENCY_LEVEL = 16;：默认并发数
static final int MAXIMUM_CAPACITY = 1 << 30;：最大容量
static final int MIN_SEGMENT_TABLE_CAPACITY = 2;：最小容量保证2的倍数
static final int MAX_SEGMENTS = 1 << 16; 最大并发数

常量主要用于默认初始化时的数值

构造方法

为了便于理解主要以默认值进行介绍

public ConcurrentHashMap(int initialCapacity, float loadFactor) {
        this(initialCapacity, loadFactor, DEFAULT_CONCURRENCY_LEVEL);
}
public ConcurrentHashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);
}
//默认初始化均采用默认值
public ConcurrentHashMap() {
        this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);
}
//上边3个都是调用这个构造
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;
        // 这主要保证并发数是2的倍数
        int sshift = 0;
        int ssize = 1;
        while (ssize < concurrencyLevel) {
            ++sshift;
            ssize <<= 1;
        }
        //通过上边的操作，sshift=4，ssize=16，计算出segmentShift=28，
        //segmentMask=15，下边会用到这两个值
        this.segmentShift = 32 - sshift;
        this.segmentMask = ssize - 1;
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        //计算每个Segment中数组大小initialCapacity采用默认值16，
        //ssize=16，则每个分配的是1.
        int c = initialCapacity / ssize;
        if (c * ssize < initialCapacity)
            ++c;
        //cap默认为2
        int cap = MIN_SEGMENT_TABLE_CAPACITY;
        while (cap < c)
            cap <<= 1;
        // 初始化Segments，创建segment[0]
        Segment<K,V> s0 =
            new Segment<K,V>(loadFactor, (int)(cap * loadFactor),
                             (HashEntry<K,V>[])new HashEntry[cap]);
        //初始化Segment大小
        Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize];
        //将s0放到ss数组中
        UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]
        this.segments = ss;
}

构造看起来比较简单，得到一个Segment数组，并对第一个进行初始化Segment[0]

put过程浅析

public V put(K key, V value) {
        Segment<K,V> s;
        if (value == null)
            throw new NullPointerException();
        //计算hash值
        int hash = hash(key);
        //构造中计算的值segmentShift=28，segmentMask=15
        //hash是32位，无符号右移28位，得到低4位，再与segmentMask=15做与运算，最终是低4位
        int j = (hash >>> segmentShift) & segmentMask;
        if ((s = (Segment<K,V>)UNSAFE.getObject
             (segments, (j << SSHIFT) + SBASE)) == null)
            //初始化对应位置segment[j]
            s = ensureSegment(j);
        //将值放到segment中
        return s.put(key, hash, value, false);
}

外层代码不复杂，通过hash找到对应位置的segment，如果为null则进行初始化并加值放到初始化的segment中，

• 初始化ensureSegment

private Segment<K,V> ensureSegment(int k) {
		//segments为构造中初始化的数组
        final Segment<K,V>[] ss = this.segments;
        long u = (k << SSHIFT) + SBASE; // raw offset
        Segment<K,V> seg;
        //判断指定位置的segment是否为null
        if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u)) == null) {
        	//若为null，则进行初始化，这里采用ss[0]的值进行初始化
            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);
            //初始化segment内部数组大小
            HashEntry<K,V>[] tab = (HashEntry<K,V>[])new HashEntry[cap];
            if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))
                == null) { // 再次检查是否为null，若为null则初始化segment
                Segment<K,V> s = new Segment<K,V>(lf, threshold, tab);
                //循环检查
                while ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))
                       == null) {
                    //采用CAS机制，若当前线程赋值成功或者其他线程赋值成功则跳出循环
                    if (UNSAFE.compareAndSwapObject(ss, u, null, seg = s))
                        break;
                }
            }
        }
        return seg;
}

初始化采用ss[0]的各个参数值进行初始化，采用CAS来对初始化保证线程安全，只要有一个线程成功则跳出循环。

• segment内部put数据

final V put(K key, int hash, V value, boolean onlyIfAbsent) {
			//采用ReentrantLock的tryLock尝试获取锁获取不到则尝试获取写入锁
            HashEntry<K,V> node = tryLock() ? null :
                scanAndLockForPut(key, hash, value);
            V oldValue;
            try {
            	//segment内部数组
                HashEntry<K,V>[] tab = table;
                int index = (tab.length - 1) & hash;
                //获取链表头
                HashEntry<K,V> first = entryAt(tab, index);
                for (HashEntry<K,V> e = first;;) {
                	//链表头不为null
                    if (e != null) {
                        K k;
                        //如果存在对应key则更新value，返回旧值
                        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 {
                    	//若不为null，则表示有数据，设置next
                        if (node != null)
                            node.setNext(first);
                        else
                        	//否则初始化
                            node = new HashEntry<K,V>(hash, key, value, first);
                        //长度加1
                        int c = count + 1;
                        //超过阀值则进行扩容
                        if (c > threshold && tab.length < MAXIMUM_CAPACITY)
                        	//下面再介绍
                            rehash(node);
                        else
                        	//将新值加到链表中
                            setEntryAt(tab, index, node);
                        ++modCount;
                        count = c;
                        oldValue = null;
                        break;
                    }
                }
            } finally {
                unlock();
            }
            return oldValue;
 }

这个过程主要是先获取锁，然后再根据位置查询是否存在若存在则更新并返回旧值，不存在则进行添加，添加前判断是否需要扩容，如果需要则扩容，不需要直接加到链表中。

• 获取写入锁scanAndLockForPut

private HashEntry<K,V> scanAndLockForPut(K key, int hash, V value) {
			//获取segment中hash位置数据
            HashEntry<K,V> first = entryForHash(this, hash);
            HashEntry<K,V> e = first;
            HashEntry<K,V> node = null;
            int retries = -1; 
            while (!tryLock()) {
                HashEntry<K,V> f; 
                if (retries < 0) {
                	//如果链表头为null并且node也为null，则创建节点
                    if (e == null) {
                        if (node == null) 
                            node = new HashEntry<K,V>(hash, key, value, null);
                        //将重试次数置为0
                        retries = 0;
                    }
                    //如果头节点不为null则查看是不是有对应key，若有重试次数置为0
                    else if (key.equals(e.key))
                        retries = 0;
                    else
                    	//从上边的代码看e是first，现在e的next赋给e，那么e就相当于first的next节点了,
                    	//说白了就是顺着链表往下走
                        e = e.next;
                }
                //重试次数大于最大重试次数了则加锁获取到锁后跳出循环
                else if (++retries > MAX_SCAN_RETRIES) {
                	//加锁，实际是ReentrantLock中的lock
                    lock();
                    break;
                }
                //如果重试次数不为0并且小于最大次数，则让重试次数与1做与运算，取低1位，并且segmengt的hash位置的hashEntry是否是头节点
                else if ((retries & 1) == 0 &&
                         (f = entryForHash(this, hash)) != first) {
                    //这里就是开头的一样，开头是first=entryForHash(this, hash)
                    //现在是f=entryForHash(this, hash)，但是又把f给first了
                    //进而又给到e，然后retries-1，就跟原来一样的
                    //其实就是把现在的流程又重新走了一遍
                    e = first = f; // re-traverse if entry changed
                    retries = -1;
                }
            }
            return node;
}

这个看着挺复杂的其实就是获取锁，有两个地方可以结束循环，第一个就是while获取到锁了，直接退出，第二个是在循环重试的次数大于最大次数了则直接lock获取到锁后，跳出循环。

• 扩容rehash

private void rehash(HashEntry<K,V> node) {
			//将当前table设置为旧的
            HashEntry<K,V>[] oldTable = table;
            int oldCapacity = oldTable.length;
            //将数组大小扩大2倍
            int newCapacity = oldCapacity << 1;
            //重新计算阀值
            threshold = (int)(newCapacity * loadFactor);
            //创建新的数组，采用默认值是2（初始化时计算得出）现在就是4
            HashEntry<K,V>[] newTable =
                (HashEntry<K,V>[]) new HashEntry[newCapacity];
            //sizeMask可以看做是偏移量
            int sizeMask = newCapacity - 1;
            for (int i = 0; i < oldCapacity ; i++) {
            	//循环的是将旧table中的值取出
                HashEntry<K,V> e = oldTable[i];
                if (e != null) {
                    HashEntry<K,V> next = e.next;
                    //重新计算下标值
                    int idx = e.hash & sizeMask;
                    //如果next为null说明当前数组中就自己，那么将其放到新数组中
                    if (next == null)   //  Single node on list
                        newTable[idx] = e;
                    else {
                    	//若不为Null，则有其他节点，旧表中的值
                        HashEntry<K,V> lastRun = e;
                        int lastIdx = idx;
                        //此循环主要是找到一个节点lastRun，及后边所有
                        //节点放到一起
                        for (HashEntry<K,V> last = next;
                             last != null;
                             last = last.next) {
                            int k = last.hash & sizeMask;
                            if (k != lastIdx) {
                                lastIdx = k;
                                lastRun = last;
                            }
                        }
                        //放到新数组中
                        newTable[lastIdx] = lastRun;
                        // 克隆剩下的节点
                        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;
            node.setNext(newTable[nodeIndex]);
            newTable[nodeIndex] = node;
            table = newTable;
}

这个扩容比较复杂，首先是创建新数组，然后循环遍历旧数组在每个链表中找到一个节点，将其及其后的节点放到新数组中，然后在将找到的lastRun节点之前的放到新数组中，最后将新增加的数据放到新数组中。
其中两个循环中的第一个循环是为了减小克隆的次数，如果lastRun靠前还是比较有意义的，这样克隆的比较少，若lastRun比较靠后，还是不太好的。

get过程浅析

public V get(Object key) {
        Segment<K,V> s; 
        HashEntry<K,V>[] tab;
        //计算hash
        int h = hash(key);
        long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
        //根据计算的值找到segment及数组
        if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&
            (tab = s.table) != null) {
            //若都不为null，则循环查找是否存在对应key，若有则返回值
            for (HashEntry<K,V> e = (HashEntry<K,V>) UNSAFE.getObjectVolatile
                     (tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE);
                 e != null; e = e.next) {
                K k;
                if ((k = e.key) == key || (e.hash == h && key.equals(k)))
                    return e.value;
            }
        }
        return null;
}

ConcurrentHashMap相较于HashMap在Put过程中要复杂的多，在并发安全方面主要是ReetrantLock的tryLock来保证安全的。
大家可以关注我的公众号，公众号也会同步更新相关内容。