JDK1.6的ConcurrentHashMap

1、构造函数：

       在构造函数中，主要就是根据ConcurrentHashMap的loadfactor、initialCapacity和concurrencyLevel来初始化这个ConcurrentHashMap。下面分别来介绍这几个参数的意义。

if (c++ > threshold) // ensure capacity        rehash();

       loadfactor是ConcurrentHashMap.Segment的负载因子。当Segment中元素的数目达到了threshold，就会调用rehash来扩容。Segment中的threshold的大小=Segment中表的大小*loadfactor。loadfactor的默认大小是0.75，代表当元素数目达到表的3/4的时候就会对这个Segment进行扩容。

if (concurrencyLevel > MAX_SEGMENTS)            concurrencyLevel = MAX_SEGMENTS;        // Find power-of-two sizes best matching arguments        int sshift = 0;        int ssize = 1;        while (ssize < concurrencyLevel) {            ++sshift;            ssize <<= 1;        }        segmentShift = 32 - sshift;        segmentMask = ssize - 1;        this.segments = Segment.newArray(ssize);

       concurrencyLevel是代表这个ConcurrentHashMap支持并发的等级，也就是有多少个Segment。concurrencyLevel的大小总是2的指数次方，并且不会超过1<<16。

if (initialCapacity > MAXIMUM_CAPACITY)            initialCapacity = MAXIMUM_CAPACITY;        int c = initialCapacity / ssize;        if (c * ssize < initialCapacity)            ++c;        int cap = 1;        while (cap < c)            cap <<= 1;        for (int i = 0; i < this.segments.length; ++i)            this.segments[i] = new Segment<K,V>(cap, loadFactor);

       initialCapacity是代表当前ConcurrentHashMap中的初始大小，并不是每个Segment的大小，initialCapacity不超过1<<30。注意代码中的cap，Segment的大小永远都是2的整数次幂大小，这样能使元素更加平均的分布到segments中。

2、Segment

       Segment是一种分片锁的思想，在介绍ConcurrentHashMap的其他方法之前要先知道Segment的一些属性的作用。

transient volatile int count; //<span style="font-size:12px;">Segment中的元素数目</span>。        transient int modCount; //Segment中修改元素的次数。        transient int threshold; //扩容Segment的阈值。        transient volatile HashEntry<K,V>[] table; //Segment储存元素的地方。        final float loadFactor; //负载因子。

       modCount调用的地方有put、remove、clear。replace则不会调用modCount，因为它没有Segment的表的物理结构。

final Segment<K,V> segmentFor(int hash) {        return segments[(hash >>> segmentShift) & segmentMask];    }

根据hash的高位来将该键值对放在不同的Segment。

3、put

       put方法有两个版本，put和putIfAbsent。这两个方法的区别就是当key在ConcurrentHashMap已经存在的时候是否替换value。

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值计算地址取链表头。遍历链表，寻找Key是否已经在表里存在了，如果没有存在则直接从链表头插入，如果已经存在则要根据onlyIfAbsent来判断是否需要替换oldValue。返回oldValue，解锁。

4、rehash

       rehash这个的访问权限是default的，所以只有子类和同包的类才可以调用它。在ConcurrentHashMap中发现只有Segment的put方法才调用了rehash，所以在rehash中并不需要加锁来防止出现并发问题。

void rehash() {            HashEntry<K,V>[] oldTable = table;            int oldCapacity = oldTable.length;            if (oldCapacity >= MAXIMUM_CAPACITY)                return;            HashEntry<K,V>[] newTable = HashEntry.newArray(oldCapacity<<1);            threshold = (int)(newTable.length * loadFactor);            int sizeMask = newTable.length - 1;            for (int i = 0; i < oldCapacity ; i++) {                // We need to guarantee that any existing reads of old Map can                //  proceed. So we cannot yet null out each bin.                HashEntry<K,V> e = oldTable[i];                if (e != null) {                    HashEntry<K,V> next = e.next;                    int idx = e.hash & sizeMask;                    //  Single node on list                    if (next == null)                        newTable[idx] = e;                    else {                        // Reuse trailing 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 all remaining nodes                        for (HashEntry<K,V> p = e; p != lastRun; p = p.next) {                            int k = p.hash & sizeMask;                            HashEntry<K,V> n = newTable[k];                            newTable[k] = new HashEntry<K,V>(p.key, p.hash,                                                             n, p.value);                        }                    }                }            }            table = newTable;        }

       获得Segment表的大小oldTable.length，然后乘2判断是否超过1<<30。如果大于直接返回。否则会使用oldTable.length<<1创建新的数组，并且计算新的threshold。接下来遍历oldTable把每个链表中的Entry重新插入到Segment中。因为Segment的大小是2的整数次幂，所以原来位置链表中的Entry只有两个选择，一个是插入在原位curIdx的链表中，一个是插入到oldTable.length+curIdx的链表中。源码中的处理方式，获得i位置上的链表头。如果非空，则判断next是否为空，如果next非空直接插入到对应位置做为链表头。如果next不为空，则需要先遍历一次链表，寻找最后一个idx不同的Entry。这里的优化措施就是第一次遍历链表记录下lastRun，lastRun后面的Entry的idx都和lastRun的idx相同，所以不需要多次插入，只需把lastRun及lastRun后面的节点一次插入到新链表的头后，然后开始重新遍历链表，将剩余的表中Entry插入到链表头中去。

5、get

       get也会交给相应的Segment中去操作。但是get不会对表的结构产生改变，所以不用加锁。但是如果不加锁的话会产生一致性的问题，put到Segment中的Entry，如果并发读可能会访问不到相应的Entry。所以ConcurrentHashMap中的get是弱一致性的(具体方法大家可以参考http://ifeve.com/concurrenthashmap-weakly-consistent/)。

V get(Object key, int hash) {            if (count != 0) { // read-volatile                HashEntry<K,V> e = getFirst(hash);                while (e != null) {                    if (e.hash == hash && key.equals(e.key)) {                        V v = e.value;                        if (v != null)                            return v;                        return readValueUnderLock(e); // recheck                    }                    e = e.next;                }            }            return null;        }

这里的count != 0的注释和put方法中的count=c的注释就解释了这两个操作是hb的，但是无法保证操作的原子性，所以没办法达到强一致性。

6、contain、containsValue

       contain就是调用了containValue，下面上containsValue的源码。

public boolean containsValue(Object value) {        if (value == null)            throw new NullPointerException();        // See explanation of modCount use above        final Segment<K,V>[] segments = this.segments;        int[] mc = new int[segments.length];        // Try a few times without locking        for (int k = 0; k < RETRIES_BEFORE_LOCK; ++k) {            int sum = 0;            int mcsum = 0;            for (int i = 0; i < segments.length; ++i) {                int c = segments[i].count;                mcsum += mc[i] = segments[i].modCount;                if (segments[i].containsValue(value))                    return true;            }            boolean cleanSweep = true;            if (mcsum != 0) {                for (int i = 0; i < segments.length; ++i) {                    int c = segments[i].count;                    if (mc[i] != segments[i].modCount) {                        cleanSweep = false;                        break;                    }                }            }            if (cleanSweep)                return false;        }        // Resort to locking all segments        for (int i = 0; i < segments.length; ++i)            segments[i].lock();        boolean found = false;        try {            for (int i = 0; i < segments.length; ++i) {                if (segments[i].containsValue(value)) {                    found = true;                    break;                }            }        } finally {            for (int i = 0; i < segments.length; ++i)                segments[i].unlock();        }        return found;    }

       判断ConcurrentHashMap中是否包含某个value就要在每个Segment去寻找是否包含这个value。首先先创建的mc数组就是记录每个Segment的modCount，然后去执行遍历查找操作，查找成功则会返回true。如果不成功则会再次遍历Segments的modCount去和mc中的每个值去比较，判断是否某个Segment发生了改变。如果发生了改变，cleanSweep被设置为false，则会重新进行。直到每个Segment在这期间都没有被修改过，然后会返回false。int c = segments[i].modCount;保证了可见性。如果每次都发现segments的Entry被修改过，那么重试次数达到RETRIES_BEFORE_LOCK的时候就会继续跳过无锁化的查找，对每个Segment进行加锁，然后再进行查找。

7、isEmpty

public boolean isEmpty() {        final Segment<K,V>[] segments = this.segments;        int[] mc = new int[segments.length];        int mcsum = 0;        for (int i = 0; i < segments.length; ++i) {            if (segments[i].count != 0)                return false;            else                mcsum += mc[i] = segments[i].modCount;        }                if (mcsum != 0) {            for (int i = 0; i < segments.length; ++i) {                if (segments[i].count != 0 ||                    mc[i] != segments[i].modCount)                    return false;            }        }        return true;    }

       在isEmpty中还是使用了记录segments的modCount的方式来进行统计，第一遍统计，如果有某个Segment的count不为0则直接返回false，如果统计segments的count都为0，那么需要第二次遍历segments，如果遍历的时候某个Segment的count不为0则直接返回false。如果某个Segment的count为0，并且modCount不为0，说明发生了ABA问题，那么就返回false，因为在isEmpty统计的过程中，segments并不为空。

转载请标明出处：http://blog.csdn.net/hahaha1232