HashMap是线程不安全的,所以jdk提供了ConcurrentHashMap 这个线程安全的map集合实现,这一篇文章来分析下jdk7中ConcurrentHashMap 的实现原理

一、分段锁 Segment

jdk7中ConcurrentHashMap 的实现使用了分段锁的思想。

先来思考下Hashtable是一个线程安全的map,但为什么它的效率不高呢?

因为它里边的所有方法都是被synchronized修饰的,这样当一个线程t1进行put操作时,另一个线程t2就不能进行put或者get操作即使他们操作的是不同的数组下标,所以说它的效率低,同时只能允许一个线程进行操作。

分段锁的思想就是为了解决这种效率问题,我们先给出一张图来说明下。

相比于HashMap,ConcurrentHashMap 的实现中多嵌套了一层Segment数组,而这个Segment对象就是分段锁,可以理解成它就是一个小型的HashMap,

当两个线程t1和t2同时进行put操作时,会先根据key的hash值计算出要存放

在Segment数组的那个下标处,假设t1和t2计算出的下标不一样,那么他们就会各自去找到自己需要的Segment对象去进行put(调用segment对象的put方法),加锁是在segment对象的内部实现的,这样就实现了两个线程的put操作互不干扰,提高了效率,当然如果两个线程要操作的是Segment数组的同一个下标,那还是需要竞争锁的,这就是jdk7中分段锁的实现原理。

二、构造方法

先从构造方法看起,了解下构造方法的几个参数和HashMap的有什么不同

//无参数的构造方法,调用有参数的构造方法,传递了几个默认值
public ConcurrentHashMap() {
        this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);
}
//我们来详细看下这几个参数的含义
/**
 * initialCapacity map的初始容量,注意这个容量是整个map的容量 
    也就是 容量= 并发级别* 每个Segment对象中entry数组的长度,创建Segment对象时就是根据这个关系计算内部
    Entry数组的容量
 * loadFactor 负载因子,和扩容相关
 * concurrencyLevel map的并发级别,即map最多支持几个线程同时操作,也就是Segment数组的长度
*/
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;
    	//底下这个循环是在计算真正的并发级别,根据传入的数字,得到一个比它大的最小的2的次方数,
        //计算得到的ssize会作为segment数组的容量,注意这个容量确定后后边就不会再变了
        int ssize = 1;
        while (ssize < concurrencyLevel) {
            ++sshift;
            ssize <<= 1;
        }
        this.segmentShift = 32 - sshift;
        this.segmentMask = ssize - 1;
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
    	//这里是在计算每个Segment对象中Entry数组的长度,
        //初始容量/计算出的并发度,注意这里是用int接收,如果除不尽就会只保留整数部分,
        int c = initialCapacity / ssize;
        //这里是检验算出的c*并发度是否满足传入的初始容量,如果不满足就给它加1
        if (c * ssize < initialCapacity)
            ++c;
       //这个常量表示Entry数组最小的长度是2
        int cap = MIN_SEGMENT_TABLE_CAPACITY;
        //如果上边算出的容量比2大,就cap*2继续和c比较,最后得当的cap是一个比c大的2的次方数,
        //为什么一定要是2的次方数这和Segment对象中计算待put的key的下标的方式有关
        while (cap < c)
            cap <<= 1;
        // create segments and segments[0]
        //创建Segment数组0下标处的Segment对象
        Segment<K,V> s0 =
            new Segment<K,V>(loadFactor, (int)(cap * loadFactor),
                             /*这个数组就是Segment内部Entry数组*/
                             (HashEntry<K,V>[])new HashEntry[cap]);
        //创建Segment数组
        Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize];
        //用UNSAFE对象把s0放到ss的0号下标处,这里使用UNSAFE是为了直接操作主内存
        UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]
        this.segments = ss;
    }

注意到这个构造方法中比HashMap的构造方法多了一个concurrencyLevel,并发级别,它表示最多可以同时允许多少个线程同时操作,对应的是Segment数组的容量。

三、put方法

put方法的思想是先计算出key应该放在外层Segment数组的那个下标处,然后再调用Segment对象的put方法。

public V put(K key, V value) {
        Segment<K,V> s;
        if (value == null)
            throw new NullPointerException();
        int hash = hash(key);
        //计算key对应的Segment数组下标, hash值 & 数组长度-1,和hashmap类似
        int j = (hash >>> segmentShift) & segmentMask;
        // 这个if条件里边用UNSAFE对象从Segment数组中获取下标j处的对象,
    	if ((s = (Segment<K,V>)UNSAFE.getObject          // nonvolatile; recheck
             (segments, (j << SSHIFT) + SBASE)) == null) //  in ensureSegment
            //如果获取到的对象是空就需要新创建一个
            //这个方法内部就是创建一个Segemnt对象放在Segment数组的j下标处,
            //内部用多重检查和cas操作保证了只有一个线程会创建对象并放到数组下标处成功
            s = ensureSegment(j);
        //调用Segemnt对象的put方法
        return s.put(key, hash, value, false);
 }

 //这是Segemnt对象内部的put方法
	final V put(K key, int hash, V value, boolean onlyIfAbsent) {
        	//尝试获取锁,如果失败了就执行scanAndLockForPut,这里边是在继续尝试获取锁,并做
            // 一些准备工作,尝试次数到达一定限度就会改成用阻塞的方式获取锁
            HashEntry<K,V> node = tryLock() ? null :
                scanAndLockForPut(key, hash, value);
            V oldValue;
        	//能走到这里表示当前线程已经成功获取到了锁
            try {
                HashEntry<K,V>[] tab = table;
                //计算key对应的Entry数组下标
                int index = (tab.length - 1) & hash;
                //取出下标处的元素
                HashEntry<K,V> first = entryAt(tab, index);
                //循环下标处的链表
                for (HashEntry<K,V> e = first;;) {
                    if (e != null) {
                        K k;
                        //这里是在判断链表上的某个元素的key是否和传入的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 {
                        //这个else表示遍历到了链表的最后一个节点
                        //这个node就是针对要put的key/value创建的节点,它有可能在上边尝试获取锁的
                        //的时候提前创建了,如果没有这里就重新创建然后加入原来的链表,
                        //jdk7采用的是头插法
                        if (node != null)
                            node.setNext(first);
                        else
                            node = new HashEntry<K,V>(hash, key, value, first);
                        int c = count + 1;
                        if (c > threshold && tab.length < MAXIMUM_CAPACITY)
                            //校验容量看是否需要扩容
                            rehash(node);
                        else
                            //这里边利用unsfafe修改entry数组下标index处的元素为新创建的node
                            setEntryAt(tab, index, node);
                        ++modCount;
                        count = c;
                        oldValue = null;
                        break;
                    }
                }
            } finally {
                unlock();
            }
            return oldValue;
        }

可以看到put时是先确定往哪个Segment对象放,然后在Segment对象内部加锁进行put,这就是分段锁的体现。

四、扩容方法

上边在put方法里边提到了put一个元素的过程中会校验是否需要扩容,如果需要就会调用扩容方法,

要注意的是扩容值是把当前Segment对象内部的Entry数组进行扩容,并不会影响其他的Segment对象,同时注意扩容只扩Segment对象内部,Segment数组是不扩容的,也就是并发级别是不会变的。

扩容的过程就是先创建一个容量是原来数组两倍的新数组,然后遍历就数组的每一个下标,再遍历下标处的链表,重新计算每个元素在数组的下标并搬到新数组中。

扩容是支持多个线程同时扩容的,注意是每个线程对不同的Segment对象进行扩容。