Java常用并发容器总结(二)

ConcurrentHashMap

1.介绍

ConcurrentHashMap是一个高效并发的HashMap,它采用了减小锁粒度的手段，内部进一步细分成了若干个小的HashMap,称为Segment段。默认情况下，一个ConcurrentHashMap被分为16个段。多ConcurrentHashMap操作时，并不是将整个ConcurrentHashMap加锁，而是首先根据hashCode定位到要操作的Segment,然后对该段进行加锁。在多线程环境下，如果多个线程操作同一个ConcurrentHashMap的不同Segment,可以做到真正的并行，大大提高了效率。

2.代码分析

下面以ConcurrentHashMap的put()方法为例，分析ConcurrentHashMap的操作策略：

public V put(K key, V value) {
        Segment<K,V> s;
        if (value == null)
            throw new NullPointerException();

        //计算key的hashCode
        int hash = hash(key);

        //根据hashCode,找到要进行操作的段
        int j = (hash >>> segmentShift) & segmentMask;
        if ((s = (Segment<K,V>)UNSAFE.getObject          
             (segments, (j << SSHIFT) + SBASE)) == null)
            s = ensureSegment(j);

        //对该段进行put
        return s.put(key, hash, value, false);
    }

可以看出，对ConcurrentHashMap的put操作，可以将粒度减小为对某一个Segment的操作，大大减小了锁的竞争，提高并发效率。但是，减小锁的粒度引入了一个新的问题，当系统需要获得全局锁时，消耗的资源较多。以size()方法为例：

public int size() {       
        final Segment<K,V>[] segments = this.segments;
        int size;
        boolean overflow; 
        long sum;        
        long last = 0L;  
        int retries = -1; 
        try {
            for (;;) {
                if (retries++ == RETRIES_BEFORE_LOCK) {
                    for (int j = 0; j < segments.length; ++j)

                        //在这里，需要多每一个Segment分别加锁
                        ensureSegment(j).lock(); 
                }
                sum = 0L;
                size = 0;
                overflow = false;
                for (int j = 0; j < segments.length; ++j) {
                    Segment<K,V> seg = segmentAt(segments, j);
                    if (seg != null) {

                        //计算size总数
                        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;
    }

可以看出，在高并发的场景下,ConcurrentHashMap的size()方法的效率要明显低于HashMap。

3.适用场景

简单地说，如果想在高并发的场景下使用HashMap，那么ConcurrentHashMap将是一个很好的选择。