并发容器类：ConcurrentHashMap

HashMap 不是线程安全的，在并发场景下如果要保证一种可行的方式是使用 Collections.synchronizedMap() ，但是全局锁效率低。

initialCapacity为16，loadFactor为0.75。默认大小与hashmap相同都是16

jdk1.7版本：

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

?

1	final Segment<K,V>[] segments;

Segment继承了ReentrantLock，所以它就是一种可重入锁（ReentrantLock)。在ConcurrentHashMap，一个Segment就是一个子哈希表，Segment里维护了一个HashEntry数组，并发环境下，对于不同Segment的数据进行操作是不用考虑锁竞争的，理论上允许16个线程并发执行。

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

?

1 2 3 4 5 6 7

transient volatile HashEntry<K,V>[] table;static final class HashEntry<K,V> {         final int hash;         final K key;         volatile V value;         volatile HashEntry<K,V> next;         //其他省略 }

 

get()，读数据，不加锁，共享变量都使用volatile修饰，volatile可以保证内存可见性，所以不会读取到过期数据。

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

public V get(Object key) {         Segment<K,V> s;         HashEntry<K,V>[] tab;         int h = hash(key);         long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;        //先定位Segment，再定位HashEntry         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()，加锁

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43

final V put(K key, int hash, V value, boolean onlyIfAbsent) {             HashEntry<K,V> node = tryLock() ? null :                 scanAndLockForPut(key, hash, value);//tryLock不成功时会遍历定位到的HashEnry位置的链表（遍历主要是为了使CPU缓存链表），若找不到，则创建HashEntry。tryLock一定次数后（MAX_SCAN_RETRIES变量决定），则lock。若遍历过程中，由于其他线程的操作导致链表头结点变化，则需要重新遍历。             V oldValue;             try {                 HashEntry<K,V>[] tab = table;                 int index = (tab.length - 1) & hash;//定位HashEntry，可以看到，这个hash值在定位Segment时和在Segment中定位HashEntry都会用到，只不过定位Segment时只用到高几位。                 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;　　　　　　　　　　　　　　//若c超出阈值threshold，需要扩容并rehash。扩容后的容量是当前容量的2倍。这样可以最大程度避免之前散列好的entry重新散列，具体在另一篇文章中有详细分析，不赘述。扩容并rehash的这个过程是比较消耗资源的。                         if (c > threshold && tab.length < MAXIMUM_CAPACITY)                             rehash(node);                         else                             setEntryAt(tab, index, node);                         ++modCount;                         count = c;                         oldValue = null;                         break;                     }                 }             } finally {                 unlock();             }             return oldValue;         }

 

JDK1.8  不再采用分段锁，采用CAS和synchronized来保证并发安全

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

/*      * 用来返回节点数组的指定位置的节点的原子操作      */     @SuppressWarnings("unchecked")     static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab, int i) {         return (Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);     }       /*      * cas原子操作，在指定位置设定值      */     static final <K,V> boolean casTabAt(Node<K,V>[] tab, int i,                                         Node<K,V> c, Node<K,V> v) {         return U.compareAndSwapObject(tab, ((long)i << ASHIFT) + ABASE, c, v);     }     /*      * 原子操作，在指定位置设定值      */     static final <K,V> void setTabAt(Node<K,V>[] tab, int i, Node<K,V> v) {         U.putObjectVolatile(tab, ((long)i << ASHIFT) + ABASE, v);     }

　　CAS：用在当目标数组位置没有元素时，使用CAS进行添加

　　如果目标地址有元素，则使用通过synchronized来加锁，进行添加操作

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91

/*      * 当添加一对键值对的时候，首先会去判断保存这些键值对的数组是不是初始化了，      * 如果没有的话就初始化数组      *  然后通过计算hash值来确定放在数组的哪个位置      * 如果这个位置为空则直接添加，如果不为空的话，则取出这个节点来      * 如果取出来的节点的hash值是MOVED(-1)的话，则表示当前正在对这个数组进行扩容，复制到新的数组，则当前线程也去帮助复制      * 最后一种情况就是，如果这个节点，不为空，也不在扩容，则通过synchronized来加锁，进行添加操作      *    然后判断当前取出的节点位置存放的是链表还是树      *    如果是链表的话，则遍历整个链表，直到取出来的节点的key来个要放的key进行比较，如果key相等，并且key的hash值也相等的话，      *          则说明是同一个key，则覆盖掉value，否则的话则添加到链表的末尾      *    如果是树的话，则调用putTreeVal方法把这个元素添加到树中去      *  最后在添加完成之后，会判断在该节点处共有多少个节点（注意是添加前的个数），如果达到8个以上了的话，      *  则调用treeifyBin方法来尝试将处的链表转为树，或者扩容数组      */     final V putVal(K key, V value, boolean onlyIfAbsent) {         if (key == null || value == null) throw new NullPointerException();//K,V都不能为空，否则的话跑出异常         int hash = spread(key.hashCode());    //取得key的hash值         int binCount = 0;    //用来计算在这个节点总共有多少个元素，用来控制扩容或者转移为树         for (Node<K,V>[] tab = table;;) {    //             Node<K,V> f; int n, i, fh;             if (tab == null || (n = tab.length) == 0)                    tab = initTable();    //第一次put的时候table没有初始化，则初始化table             else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {    //通过哈希计算出一个表中的位置因为n是数组的长度，所以(n-1)&hash肯定不会出现数组越界                 if (casTabAt(tab, i, null,        //如果这个位置没有元素的话，则通过cas的方式尝试添加，注意这个时候是没有加锁的                              new Node<K,V>(hash, key, value, null)))        //创建一个Node添加到数组中区，null表示的是下一个节点为空                     break;                   // no lock when adding to empty bin             }             /*              * 如果检测到某个节点的hash值是MOVED，则表示正在进行数组扩张的数据复制阶段，              * 则当前线程也会参与去复制，通过允许多线程复制的功能，一次来减少数组的复制所带来的性能损失              */             else if ((fh = f.hash) == MOVED)                    tab = helpTransfer(tab, f);             else {                 /*                  * 如果在这个位置有元素的话，就采用synchronized的方式加锁，                  *     如果是链表的话(hash大于0)，就对这个链表的所有元素进行遍历，                  *         如果找到了key和key的hash值都一样的节点，则把它的值替换到                  *         如果没找到的话，则添加在链表的最后面                  *  否则，是树的话，则调用putTreeVal方法添加到树中去                  *                   *  在添加完之后，会对该节点上关联的的数目进行判断，                  *  如果在8个以上的话，则会调用treeifyBin方法，来尝试转化为树，或者是扩容                  */                 V oldVal = null;                 synchronized (f) {                     if (tabAt(tab, i) == f) {        //再次取出要存储的位置的元素，跟前面取出来的比较                         if (fh >= 0) {                //取出来的元素的hash值大于0，当转换为树之后，hash值为-2                             binCount = 1;                                        for (Node<K,V> e = f;; ++binCount) {    //遍历这个链表                                 K ek;                                 if (e.hash == hash &&        //要存的元素的hash，key跟要存储的位置的节点的相同的时候，替换掉该节点的value即可                                     ((ek = e.key) == key ||                                      (ek != null && key.equals(ek)))) {                                     oldVal = e.val;                                     if (!onlyIfAbsent)        //当使用putIfAbsent的时候，只有在这个key没有设置值得时候才设置                                         e.val = value;                                     break;                                 }                                 Node<K,V> pred = e;                                 if ((e = e.next) == null) {    //如果不是同样的hash，同样的key的时候，则判断该节点的下一个节点是否为空，                                     pred.next = new Node<K,V>(hash, key,        //为空的话把这个要加入的节点设置为当前节点的下一个节点                                                               value, null);                                     break;                                 }                             }                         }                         else if (f instanceof TreeBin) {    //表示已经转化成红黑树类型了                             Node<K,V> p;                             binCount = 2;                             if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,    //调用putTreeVal方法，将该元素添加到树中去                                                            value)) != null) {                                 oldVal = p.val;                                 if (!onlyIfAbsent)                                     p.val = value;                             }                         }                     }                 }                 if (binCount != 0) {                     if (binCount >= TREEIFY_THRESHOLD)    //当在同一个节点的数目达到8个的时候，则扩张数组或将给节点的数据转为tree                         treeifyBin(tab, i);                        if (oldVal != null)                         return oldVal;                     break;                 }             }         }         addCount(1L, binCount);    //计数         return null;     }

　　补充CAS：

下面是sun.misc.Unsafe类的compareAndSwapInt()方法的源代码：

public final native boolean compareAndSwapInt(Object o, long offset,
                                              int expected,
                                              int x);