集合是编程中最常用的数据结构。而谈到并发，几乎总是离不开集合这类高级数据结构的支持。比如两个线程需要同时访问一个中间临界区（Queue），比如常会用缓存作为外部文件的副本（HashMap）。这篇文章主要分析jdk1.5的3种并发集合类型（concurrent，copyonright，queue）中的ConcurrentHashMap，让我们从原理上细致的了解它们，能够让我们在深度项目开发中获益非浅。

 

ConcurrentHashMap原理分析_数据



   


     更令人惊讶的是ConcurrentHashMap的读取并发，因为在读取的大多数时候都没有用到锁定，所以读取操作几乎是完全的并发操作，而写操作锁定的粒度又非常细，比起之前又更加快速（这一点在桶更多时表现得更明显些）。只有在求size等操作时才需要锁定整个表。而在迭代时，ConcurrentHashMap使用了不同于传统集合的快速失败迭代器（见之前的文章《JAVA API备忘---集合》）的另一种迭代方式，我们称为弱一致迭代器。在这种迭代方式中，当iterator被创建后集合再发生改变就不再是抛出ConcurrentModificationEx ception，取而代之的是在改变时new新的数据从而不影响原有的数据，iterator完成后再将头指针替换为新的数据，这样iterator线程可以使用原来老的数据，而写线程也可以并发的完成改变，更重要的，这保证了多个线程并发执行的连续性和扩展性，是性能提升的关键。 


V get(Object key, int hash) {
             if (count != 0) { // read-volatile
                 HashEntry 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;



V readValueUnderLock(HashEntry e) {
             lock();
             try {
                 return e.value;
             } finally {
                 unlock();
             }


  

V put(K key, int hash, V value, boolean onlyIfAbsent) {
             lock();
             try {
                 int c = count;
                 if (c++ > threshold) // ensure capacity
                     rehash();
                 HashEntry[] tab = table;
                 int index = hash & (tab.length - 1);
                 HashEntry first = (HashEntry) tab[index];
                 HashEntry e = first;
                 while (e != null && (e.hash != hash || !key.equals(e.key)))
                                   V oldValue;
                 if (e != null) {
                     oldValue = e.value;
                     if (!onlyIfAbsent)
                         e.value = value;
                 }
                 else {
                     oldValue = null;
                     ++modCount;
                     tab[index] = new HashEntry(key, hash, first, value);
                     count = c; // write-volatile
                 }
                 return oldValue;
             } finally {
                 unlock();
             }


  

V remove(Object key, int hash, Object value) {
             lock();
             try {
                 int c = count - 1;
                 HashEntry[] tab = table;
                 int index = hash & (tab.length - 1);
                 HashEntry first = (HashEntry)tab[index];
                 HashEntry e = first;
                 while (e != null && (e.hash != hash || !key.equals(e.key)))
                                   V oldValue = null;
                 if (e != null) {
                     V v = e.value;
                     if (value == null || value.equals(v)) {
                         oldValue = v;
                         // All entries following removed node can stay
                         // in list, but all preceding ones need to be
                         // cloned.
                         ++modCount;
                         HashEntry newFirst = e.next;
                     *    for (HashEntry p = first; p != e; p = p.next)
                     *        newFirst = new HashEntry(p.key, p.hash, 
                                                           newFirst, p.value);
                         tab[index] = newFirst;
                         count = c; // write-volatile
                     }
                 }
                 return oldValue;
             } finally {
                 unlock();
             }


static final class HashEntry {
         final K key;
         final int hash;
         volatile V value;
               HashEntry(K key, int hash, HashEntry next, V value) {
             this.key = key;
             this.hash = hash;
             this.next = next;
             this.value = value;
         }



   接下来实际上还有一个疑问，ConcurrentHashMap跟HashMap相比较性能到底如何。这在Brian Goetz的文章中已经有过评测​​http://www.ibm.com/developerworks/cn/java/j-jtp07233/​​。