JDK之ConcurrentHashMap原理

ConcurrentHashMap简介

ConcurrentHashMap分成一个一个的段。然后每次要put或get元素的时候，通过hash方法先找到这个段，然后在段上执行put或get。在put时会对segment加锁，get时不会加锁。所以ConcurrentHashMap特别适合读多写少的时候的应用。

ConcurrentHashMap主要数据结构

1)segment

看下ConcurrentHashMap的segment这个属性，它是由final修饰的，就是这个数组的大小是不会变的了，如果要扩容的话，是在segment里头扩容，防止了对整个ConcurrentHashMap扩容。

    final Segment<K,V>[] segments;

2) HashEntry

Segmen里面有下面这个属性

        transient volatile HashEntry<K,V>[] table;

在看下HashEntry，value申明成volatile，保证了多线程时安全，其它都是final的说明，都不可修改，就是说只能在链表的头部插入，尾部和中间都是插入不了的。保护了链表的完整性。

    static final class HashEntry<K,V> {
        final K key;
        final int hash;
        volatile V value;
        final HashEntry<K,V> next;

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

	@SuppressWarnings("unchecked")
	static final <K,V> HashEntry<K,V>[] newArray(int i) {
	    return new HashEntry[i];
	}
    }

再来看看ConcurrentHashMap的put方法

    public V put(K key, V value) {
        if (value == null)
            throw new NullPointerException();
        int hash = hash(key.hashCode());
        return segmentFor(hash).put(key, hash, value, false);
    }

就是通过segmentFor方法找到那个segment，然后交给那个segment去进行put操作

在看看Segment类中的put方法

        V put(K key, int hash, V value, boolean onlyIfAbsent) {
            lock();
            try {
                int c = count;
                if (c++ > threshold) // ensure capacity
                    rehash();
                HashEntry<K,V>[] tab = table;
                int index = hash & (tab.length - 1);
                HashEntry<K,V> first = tab[index];
                HashEntry<K,V> e = first;
                while (e != null && (e.hash != hash || !key.equals(e.key)))
                    e = e.next;

                V oldValue;
                if (e != null) {
                    oldValue = e.value;
                    if (!onlyIfAbsent)
                        e.value = value;
                }
                else {
                    oldValue = null;
                    ++modCount;
                    tab[index] = new HashEntry<K,V>(key, hash, first, value);
                    count = c; // write-volatile
                }
                return oldValue;
            } finally {
                unlock();
            }
        }

就是先加了个锁，然后通过hash值找到对象的数组下标。然后循环这些hash值相同的e节点，如果key相同就替代它的value值，否则就进行插入的动作。然后手动释放锁。

这个保证了线程的安全，有比hashtable的效率高多了。因为hashtable对它的方法都进行了同步。

ConcurrentHashMap里面有个size方法，也值得看一下。

先尝试直接计算每个段的值，计算两遍，然后进行比较如果相等，则返回这个数目，如果不等，则多试几次，如果一直不等，则尝试对所有的段进行加锁，然后计算其size，然后释放锁。

    public int size() {
        final Segment<K,V>[] segments = this.segments;
        long sum = 0;
        long check = 0;
        int[] mc = new int[segments.length];
        // Try a few times to get accurate count. On failure due to
        // continuous async changes in table, resort to locking.
        for (int k = 0; k < RETRIES_BEFORE_LOCK; ++k) {
            check = 0;
            sum = 0;
            int mcsum = 0;
            for (int i = 0; i < segments.length; ++i) {
                sum += segments[i].count;
                mcsum += mc[i] = segments[i].modCount;
            }
            if (mcsum != 0) {
                for (int i = 0; i < segments.length; ++i) {
                    check += segments[i].count;
                    if (mc[i] != segments[i].modCount) {
                        check = -1; // force retry
                        break;
                    }
                }
            }
            if (check == sum)
                break;
        }
        if (check != sum) { // Resort to locking all segments
            sum = 0;
            for (int i = 0; i < segments.length; ++i)
                segments[i].lock();
            for (int i = 0; i < segments.length; ++i)
                sum += segments[i].count;
            for (int i = 0; i < segments.length; ++i)
                segments[i].unlock();
        }
        if (sum > Integer.MAX_VALUE)
            return Integer.MAX_VALUE;
        else
            return (int)sum;
    }