ConcurrentHashMap源码分析

HashMap ：先说HashMap，HashMap是线程不安全的，在并发环境下，可能会形成环状链表（扩容时可能造成，具体原因自行百度google或查看源码分析），导致get操作时，cpu空转，所以，在并发环境中使用HashMap是非常危险的。

　　HashTable ： HashTable和HashMap的实现原理几乎一样，差别无非是1.HashTable不允许key和value为null；2.HashTable是线程安全的。但是HashTable线程安全的策略实现代价却太大了，简单粗暴，get/put所有相关操作都是synchronized的，这相当于给整个哈希表加了一把大锁，多线程访问时候，只要有一个线程访问或操作该对象，那其他线程只能阻塞，相当于将所有的操作串行化，在竞争激烈的并发场景中性能就会非常差。

　HashTable性能差主要是由于所有操作需要竞争同一把锁，而如果容器中有多把锁，每一把锁锁一段数据，这样在多线程访问时不同段的数据时，就不会存在锁竞争了，这样便可以有效地提高并发效率。这就是ConcurrentHashMap所采用的"分段锁"思想。

ConcurrentHashMap采用了非常精妙的"分段锁"策略，ConcurrentHashMap的主干是个Segment数组。

Segment类似于HashMap，一个Segment维护着一个HashEntry数组

成员变量在看HashMap的源码的时候基本上已经讲解过了

 

基本上所有的构造方法最终会调用当前方法

public ConcurrentHashMap(int initialCapacity,                              float loadFactor, int concurrencyLevel) {         if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)             throw new IllegalArgumentException();         //concurrencyLevel 并发数           if (concurrencyLevel > MAX_SEGMENTS)             concurrencyLevel = MAX_SEGMENTS;         //          int sshift = 0;         int ssize = 1;         //size为Segment大小         while (ssize < concurrencyLevel) {             ++sshift;             ssize <<= 1;         }         //segmentShift和segmentMask这两个变量在定位segment时会用到         this.segmentShift = 32 - sshift;         this.segmentMask = ssize - 1;         //初始化大小是否大于最大值         if (initialCapacity > MAXIMUM_CAPACITY)             initialCapacity = MAXIMUM_CAPACITY;         int c = initialCapacity / ssize;         if (c * ssize < initialCapacity)             ++c;         int cap = MIN_SEGMENT_TABLE_CAPACITY; //2         while (cap < c)             cap <<= 1;         //创建 segments    cap*loadFactor 扩容阀值 cap HashEntry大小         Segment<K,V> s0 =             new Segment<K,V>(loadFactor, (int)(cap * loadFactor),                              (HashEntry<K,V>[])new HashEntry[cap]);         //创建segments数组         Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize];         UNSAFE.putOrderedObject(ss, SBASE, s0);          this.segments = ss;     }

put方法讲解（UNSAFE自己可以去看一下）

public V put(K key, V value) {         Segment<K,V> s;         if (value == null)             throw new NullPointerException();         //根据key映射          int hash = hash(key);         //定位segment          int j = (hash >>> segmentShift) & segmentMask;         if ((s = (Segment<K,V>)UNSAFE.getObject          // nonvolatile; recheck              (segments, (j << SSHIFT) + SBASE)) == null) //  in ensureSegment         //找到对应的segment             s = ensureSegment(j); //调用对应的segment的put方法         return s.put(key, hash, value, false);     }  //找到对应的segment  如果没有则创建一个     private Segment<K,V> ensureSegment(int k) {         final Segment<K,V>[] ss = this.segments;         long u = (k << SSHIFT) + SBASE; // raw offset         Segment<K,V> seg;         if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u)) == null) {             Segment<K,V> proto = ss[0]; // use segment 0 as prototype             int cap = proto.table.length;             float lf = proto.loadFactor;             int threshold = (int)(cap * lf);             HashEntry<K,V>[] tab = (HashEntry<K,V>[])new HashEntry[cap];             if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))                 == null) { // recheck                 Segment<K,V> s = new Segment<K,V>(lf, threshold, tab);                 while ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))                        == null) {                     if (UNSAFE.compareAndSwapObject(ss, u, null, seg = s))                         break;                 }             }         }         return seg;     } 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;                 //找到对应的节点 如果有值 则更新节点  修改节点指向  没有的话 创建HashEntry 放入我们的值                 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;         }

get方法 （不需要加锁）

public V get(Object key) {         Segment<K,V> s; // manually integrate access methods to reduce overhead         HashEntry<K,V>[] tab; //计算hash值         int h = hash(key);       //找到对应segment索引值 找到对应的HashEntity  去除值         long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;         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);                  e != null; e = e.next) {                 K k;                 if ((k = e.key) == key || (e.hash == h && key.equals(k)))                     return e.value;             }         }         return null;     }

总结看懂了put方法 其他的方法都很easy 自己看 本文不做讲解

ConcurrentHashmap主要使用Segment来实现减小锁粒度，把HashMap分割成若干个Segment，在put的时候需要锁住Segment，get时候不加锁，使用volatile来保证可见性，当要统计全局时（比如size），首先会尝试多次计算modcount来确定，这几次尝试中，是否有其他线程进行了修改操作，如果没有，则直接返回size。如果有，则需要依次锁住所有的Segment来计算。