【P说】JDK 1.7及以前ConcurrentHashMap分析

简介

ConcurrentHashMap可以理解为多线程环境下HashMap，它是线程安全的。ConcurrentHashMap在JDK 1.7和JDK 1.8上的实现有很多区别，本文主要说明ConcurrentHashMap在JDK 1.7的实现。

与HashTable的区别

JDK还提供了HashTable，也是线程安全的，那么为啥我们不用HashTable，而是使用ConcurrentHashMap。因为Hashtable容器使用synchronized来保证线程安全，所以在线程竞争激烈的情况下Hashtable的效率非常低下。当一个线程访问Hashtable的同步方法时，其他线程访问Hashtable的同步方法时，可能会进入阻塞或轮询状态。如线程1使用put进行添加元素，线程2不但不能使用put方法添加元素，并且也不能使用get方法来获取元素，所以竞争越激烈效率越低。

然后定位segment和table

取得key的hash值

private int hash(Object k) {
    int h = hashSeed;

    if ((0 != h) && (k instanceof String)) {
        return sun.misc.Hashing.stringHash32((String) k);
    }

    h ^= k.hashCode();

    // Spread bits to regularize both segment and index locations,
    // using variant of single-word Wang/Jenkins hash.
    h += (h <<  15) ^ 0xffffcd7d;
    h ^= (h >>> 10);
    h += (h <<   3);
    h ^= (h >>>  6);
    h += (h <<   2) + (h << 14);
    return h ^ (h >>> 16);
}

先去Key的hash值，然后和一个随机的hash因子进行异或操作，在进行多一次hash（Wang/Jenkins hash）。

segement下标

取key hash值的几个高位与segment取模。

table下标

取key hash值与segment取模。

数据结构

首先，在ConcurrentHashMap中维护了一个大的Segment数组，我们看Segment的代码可以发现，Segment就是一个Reentrantlock，ConcurrentHashMap就是用这个Segment数组来保证多线程的安全，该Segment被称为分段锁。每个segment中都有保存一个保存链表的数组table。

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

        private static final long serialVersionUID = 2249069246763182397L;

        static final int MAX_SCAN_RETRIES =
            Runtime.getRuntime().availableProcessors() > 1 ? 64 : 1;

		//保存链表的数组
        transient volatile HashEntry<K,V>[] table;

        transient int count;

        transient int modCount;

        transient int threshold;

        final float loadFactor;

        Segment(float lf, int threshold, HashEntry<K,V>[] tab) {
            this.loadFactor = lf;
            this.threshold = threshold;
            this.table = tab;
        }

        final V put(K key, int hash, V value, boolean onlyIfAbsent) {
            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;;) {
                    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 {
                        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
                            setEntryAt(tab, index, node);
                        ++modCount;
                        count = c;
                        oldValue = null;
                        break;
                    }
                }
            } finally {
                unlock();
            }
            return oldValue;
        }

        @SuppressWarnings("unchecked")
        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;
                        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;
                        // 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;
        }

        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) {
                    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;
        }

        private void scanAndLock(Object key, int hash) {
            // similar to but simpler than scanAndLockForPut
            HashEntry<K,V> first = entryForHash(this, hash);
            HashEntry<K,V> e = first;
            int retries = -1;
            while (!tryLock()) {
                HashEntry<K,V> f;
                if (retries < 0) {
                    if (e == null || 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;
                    retries = -1;
                }
            }
        }

        final V remove(Object key, int hash, Object value) {
            if (!tryLock())
                scanAndLock(key, hash);
            V oldValue = null;
            try {
                HashEntry<K,V>[] tab = table;
                int index = (tab.length - 1) & hash;
                HashEntry<K,V> e = entryAt(tab, index);
                HashEntry<K,V> pred = null;
                while (e != null) {
                    K k;
                    HashEntry<K,V> next = e.next;
                    if ((k = e.key) == key ||
                        (e.hash == hash && key.equals(k))) {
                        V v = e.value;
                        if (value == null || value == v || value.equals(v)) {
                            if (pred == null)
                                setEntryAt(tab, index, next);
                            else
                                pred.setNext(next);
                            ++modCount;
                            --count;
                            oldValue = v;
                        }
                        break;
                    }
                    pred = e;
                    e = next;
                }
            } finally {
                unlock();
            }
            return oldValue;
        }

        final boolean replace(K key, int hash, V oldValue, V newValue) {
            if (!tryLock())
                scanAndLock(key, hash);
            boolean replaced = false;
            try {
                HashEntry<K,V> e;
                for (e = entryForHash(this, hash); e != null; e = e.next) {
                    K k;
                    if ((k = e.key) == key ||
                        (e.hash == hash && key.equals(k))) {
                        if (oldValue.equals(e.value)) {
                            e.value = newValue;
                            ++modCount;
                            replaced = true;
                        }
                        break;
                    }
                }
            } finally {
                unlock();
            }
            return replaced;
        }

        final V replace(K key, int hash, V value) {
            if (!tryLock())
                scanAndLock(key, hash);
            V oldValue = null;
            try {
                HashEntry<K,V> e;
                for (e = entryForHash(this, hash); e != null; e = e.next) {
                    K k;
                    if ((k = e.key) == key ||
                        (e.hash == hash && key.equals(k))) {
                        oldValue = e.value;
                        e.value = value;
                        ++modCount;
                        break;
                    }
                }
            } finally {
                unlock();
            }
            return oldValue;
        }

        final void clear() {
            lock();
            try {
                HashEntry<K,V>[] tab = table;
                for (int i = 0; i < tab.length ; i++)
                    setEntryAt(tab, i, null);
                ++modCount;
                count = 0;
            } finally {
                unlock();
            }
        }
    }

transient volatile HashEntry<K,V>[] table;，table是用来保存链表的，链表中保存着真正的数据。每个数据会被封装成为一个HashEntry<K,V>。

static final class HashEntry<K,V> {
	//key计算出来的哈希值
    final int hash;
    final K key;
    volatile V value;
    volatile HashEntry<K,V> next;

    HashEntry(int hash, K key, V value, HashEntry<K,V> next) {
        this.hash = hash;
        this.key = key;
        this.value = value;
        this.next = next;
    }

    final void setNext(HashEntry<K,V> n) {
        UNSAFE.putOrderedObject(this, nextOffset, n);
    }

    static final sun.misc.Unsafe UNSAFE;
    static final long nextOffset;
    static {
        try {
            UNSAFE = sun.misc.Unsafe.getUnsafe();
            Class k = HashEntry.class;
            nextOffset = UNSAFE.objectFieldOffset
                (k.getDeclaredField("next"));
        } catch (Exception e) {
            throw new Error(e);
        }
    }
}

其中我们可以看到：

volatile V value;
volatile HashEntry<K,V> next;

value和next是用volatile关键字进行修饰的，因为在ConcurrentHashMap中，只会对put方法进行上锁，而不对get方法上锁，因此需要用volatile来保证变量的可见性。但是，由于不是上锁的，可能会出现这种情况，线程A拿锁进行修改，在改之前被挂起了，线程B读取了volatile的数据之后，线程A重新调度修改完成，这会导致线程B读到的其实已经是旧数据了，这就是ConcurrentHashMap的弱一致性问题。

源码分析

初始化

首先是一些默认值。

//默认table的初始化大小，这里指定的默认大小是所有segment中table的总大小
 static final int DEFAULT_INITIAL_CAPACITY = 16;

 //table扩张的阈值
 static final float DEFAULT_LOAD_FACTOR = 0.75f;

 //segment数组的大小
 static final int DEFAULT_CONCURRENCY_LEVEL = 16;

 //最大的table数组大小
 static final int MAXIMUM_CAPACITY = 1 << 30;

 //最小segement和table的大小
 static final int MIN_SEGMENT_TABLE_CAPACITY = 2;

 //最大segement数组的大小
 static final int MAX_SEGMENTS = 1 << 16; // slightly conservative

ConcurrentHashMap的构造函数，主要是ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel)

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);
}

public ConcurrentHashMap(Map<? extends K, ? extends V> m) {
    this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
                  DEFAULT_INITIAL_CAPACITY),
         DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);
    putAll(m);
}

public ConcurrentHashMap(int initialCapacity,
                      float loadFactor, int concurrencyLevel) {
    if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0) //验参
        throw new IllegalArgumentException();
    if (concurrencyLevel > MAX_SEGMENTS) //指定的segment数组大小超出规定值
        concurrencyLevel = MAX_SEGMENTS;
    // Find power-of-two sizes best matching arguments
    int sshift = 0; 
    int ssize = 1;	
    while (ssize < concurrencyLevel) {
        ++sshift;
        ssize <<= 1;
    }
    this.segmentShift = 32 - sshift;//这个参数规定使用hash值的高位多少位来计算segment下标
    this.segmentMask = ssize - 1; //因为取模操作可以用位运算来替代，更加快速，这个参数用来帮助进行位运算。比如15%16 == 15&15
    if (initialCapacity > MAXIMUM_CAPACITY) //指定的table数组大小超出规定值
        initialCapacity = MAXIMUM_CAPACITY;
    int c = initialCapacity / ssize; //每一个segment中table的大小
    if (c * ssize < initialCapacity) //保证c为2的幂
        ++c;
    int cap = MIN_SEGMENT_TABLE_CAPACITY; //最小的单个table数组大小
    while (cap < c)
        cap <<= 1;
    // create segments and segments[0]
    Segment<K,V> s0 = //只初始化了0号位置的segment
        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;
}

如果，我们什么都不传，那么segment大小为16，单个table的大小为2。

get方法

get方法，首先要定位segement的位置，然后在定位table位置，然后在循环链表，如果找到就返回，没有找到返回null。

public V get(Object key) {
    Segment<K,V> s; // manually integrate access methods to reduce overhead
    HashEntry<K,V>[] tab;
    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) {
        for (HashEntry<K,V> e = (HashEntry<K,V>) UNSAFE.getObjectVolatile
                 (tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE); //定位到Table，并且取得table 链表的表头
             e != null; e = e.next) {
            K k;
            if ((k = e.key) == key || (e.hash == h && key.equals(k))) //对比每一个元素
                return e.value;
        }
    }
    return null;
}

put方法

@SuppressWarnings("unchecked")
public V put(K key, V value) {
    Segment<K,V> s;
    if (value == null)
        throw new NullPointerException();
    int hash = hash(key);
    int j = (hash >>> segmentShift) & segmentMask; //确定添加到那个segment中
    if ((s = (Segment<K,V>)UNSAFE.getObject         
         (segments, (j << SSHIFT) + SBASE)) == null) 
        s = ensureSegment(j); //确认segment是否被初始化，因为构造时，segment其实只初始化了第0个元素
    return s.put(key, hash, value, false); //调用segment中的put
}

segment中的put：

final V put(K key, int hash, V value, boolean onlyIfAbsent) {
    HashEntry<K,V> node = tryLock() ? null :
        scanAndLockForPut(key, hash, value); //上锁
    V oldValue;
    try {
        HashEntry<K,V>[] tab = table;
        int index = (tab.length - 1) & hash; //找到table下标
        HashEntry<K,V> first = entryAt(tab, index);
        for (HashEntry<K,V> e = first;;) {
            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 {
                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); // 扩大table的大小
                else
                    setEntryAt(tab, index, node);
                ++modCount;
                count = c;
                oldValue = null;
                break;
            }
        }
    } finally {
        unlock(); //解锁
    }
    return oldValue;
}

table大小扩张

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;
     //循环所有链表，对元素进行重新hash，然后加入新的table数组
     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;
                 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;
                 // 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;
 }

获得ConcurrentHashMap的大小

首先，会不上锁的计算两次MAP的大小，如果两次相同就直接返回，如果不同，就上锁（全部的segment）进行计算。上锁之后就无法进行put以及其他操作，会影响效率，需要特别注意。

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;
 }