Java并发——并发容器ConcurrentHashMap实现原理

一、ConcurrentHashMap的实现原理

ConcurrentHashMap的“锁分段”就是把数据分段，然后每段有一个锁，这样当不同的线程访问不同段的数据时，就不会发生锁竞争了。

那么“锁分段”是怎么实现的呢，那就需要看看ConcurrentHashMap的底层实现结构了。

ConcurrentHashMap是由Segment数组加HashEntry数组构成的，如下图所示：

其中Segment是一种可重入锁（ReentrantLock），在ConcurrentHashMap里扮演锁的角色；HashEntry用于存储键值对数据。Segment的结构和HashMap相似，是数组加链表的形式，一个Segment里包含一个HashEntry[ ]数组，每个HashEntry是一个链表的结构的元素，每个Segment守护一个HashEntry[ ]数组的元素，当要对某个HashEntry[ ]数组进行操作时，要先获取对应的Segment锁。

然后我们可以看看ConcurrentHashMap、Segment和HashEntry这三种类的继承关系：

ConcurrentHashMap：

public class ConcurrentHashMap<K,V> extends AbstractMap<K,V>
    implements ConcurrentMap<K,V>, Serializable

ConcurrentHashMap继承了AbstractMap，实现了ConcurrentMap和Serializable接口。

Segment：

static class Segment<K,V> extends ReentrantLock implements Serializable 

Segment继承了ReentrantLock类，因此是一种可重入锁。

HashEntry：

 static class Node<K,V> implements Map.Entry<K,V>

可以看出HashEntry继承了Map的Entry，可见每个HashEntry就是一个链表结构。

二、ConcurrentHashMap的使用

▶读取操作

 public V get(Object key) {
        Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
        int h = spread(key.hashCode());
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (e = tabAt(tab, (n - 1) & h)) != null) {  
            if ((eh = e.hash) == h) {
                if ((ek = e.key) == key || (ek != null && key.equals(ek)))       
                    return e.val;                                  
            }
            else if (eh < 0)
                return (p = e.find(h, key)) != null ? p.val : null;
            while ((e = e.next) != null) {
                if (e.hash == h &&
                    ((ek = e.key) == key || (ek != null && key.equals(ek))))
                    return e.val;
            }
        }
        return null;
    }

ConcurrentHashMap的get（）操作高效的原因在于不用加锁，因为get（）方法将共享变量申明为volatile的，比如用于表示segment大小的count和用于存储HashEntry的value，被声明为volatile的变量可以保持线程间的可见性，能够保证多线程可以同属读取数据且不会读到过期的值，但是volatile申明的变量在某一时间只能被一个线程写（当写入的值不依赖于原值的时候，可以允许多线程写入），在get（）操作中没有对共享变量进行写操作，因此可以不用加锁。

▶写入操作

 public V put(K key, V value) {
        return putVal(key, value, false);
    }

    /** Implementation for put and putIfAbsent */
    final V putVal(K key, V value, boolean onlyIfAbsent) {
        if (key == null || value == null) throw new NullPointerException();
        int hash = spread(key.hashCode());
        int binCount = 0;
        for (Node<K,V>[] tab = table;;) {
            Node<K,V> f; int n, i, fh;
            if (tab == null || (n = tab.length) == 0)
                tab = initTable();                              //如果当前的table数组null或者长度为0，那么初始化一个table数组
            else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
                if (casTabAt(tab, i, null,
                             new Node<K,V>(hash, key, value, null)))
                    break;                   // no lock when adding to empty bin  如果当前hash值对应的bin（桶）为null，那么使用
            }                                //CAS将当前hash对应的bin从null替换为<key, value>键值对
            else if ((fh = f.hash) == MOVED)   //tab[i] != null，并且tab[i]的hash值为MOVED，那么说明应该执行transfer扩容操作，执行完后返回新的table
                tab = helpTransfer(tab, f);
            else {
                V oldVal = null;         //如果tab[i]不为0，且容量足够，那么这时需要对当前hash值对应的Node加锁，防止其他线程改变该Node，然后找到和key相同
                synchronized (f) {       //的键值对，把value替换旧value，返回旧value
                    if (tabAt(tab, i) == f) {
                        if (fh >= 0) {
                            binCount = 1;
                            for (Node<K,V> e = f;; ++binCount) {
                                K ek;
                                if (e.hash == hash &&
                                    ((ek = e.key) == key ||
                                     (ek != null && key.equals(ek)))) {
                                    oldVal = e.val;
                                    if (!onlyIfAbsent)
                                        e.val = value;
                                    break;
                                }
                                Node<K,V> pred = e;
                                if ((e = e.next) == null) {
                                    pred.next = new Node<K,V>(hash, key,
                                                              value, null);
                                    break;
                                }
                            }
                        }
                        else if (f instanceof TreeBin) {   //如果HashEntry下的链表已经变为红黑树，则找到key对应的树节点，然后替换value，返回旧value
                            Node<K,V> p;
                            binCount = 2;
                            if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
                                                           value)) != null) {
                                oldVal = p.val;
                                if (!onlyIfAbsent)
                                    p.val = value;
                            }
                        }
                    }
                }
                if (binCount != 0) {
                    if (binCount >= TREEIFY_THRESHOLD)  //如果链表长度大于阈值，那么链表转换为红黑树
                        treeifyBin(tab, i);
                    if (oldVal != null)
                        return oldVal;
                    break;
                }
            }
        }
        addCount(1L, binCount);  //计数增加1，有可能触发transfer操作(扩容)
        return null;
    }

可以看到，如果要对已经存在的Node的执行写操作，为了线程安全，必须对要更改的Node加锁。