1     /**
 2      * Creates a new, empty map with the default initial table size (16).
 3      */
 4     public ConcurrentHashMap() {
 5     }
 6 
 7     /**
 8      * Creates a new, empty map with an initial table size
 9      * accommodating the specified number of elements without the need
10      * to dynamically resize.
11      *
12      * @param initialCapacity The implementation performs internal
13      * sizing to accommodate this many elements.
14      * @throws IllegalArgumentException if the initial capacity of
15      * elements is negative
16      */
17     public ConcurrentHashMap(int initialCapacity) {
18         if (initialCapacity < 0)
19             throw new IllegalArgumentException();
20         int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
21                    MAXIMUM_CAPACITY :
22                    tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
23         this.sizeCtl = cap;
24     }
25 
26     /**
27      * Creates a new map with the same mappings as the given map.
28      *
29      * @param m the map
30      */
31     public ConcurrentHashMap(Map<? extends K, ? extends V> m) {
32         this.sizeCtl = DEFAULT_CAPACITY;
33         putAll(m);
34     }
35 
36     /**
37      * Creates a new, empty map with an initial table size based on
38      * the given number of elements ({@code initialCapacity}) and
39      * initial table density ({@code loadFactor}).
40      *
41      * @param initialCapacity the initial capacity. The implementation
42      * performs internal sizing to accommodate this many elements,
43      * given the specified load factor.
44      * @param loadFactor the load factor (table density) for
45      * establishing the initial table size
46      * @throws IllegalArgumentException if the initial capacity of
47      * elements is negative or the load factor is nonpositive
48      *
49      * @since 1.6
50      */
51     public ConcurrentHashMap(int initialCapacity, float loadFactor) {
52         this(initialCapacity, loadFactor, 1);
53     }
54 
55     /**
56      * Creates a new, empty map with an initial table size based on
57      * the given number of elements ({@code initialCapacity}), table
58      * density ({@code loadFactor}), and number of concurrently
59      * updating threads ({@code concurrencyLevel}).
60      *
61      * @param initialCapacity the initial capacity. The implementation
62      * performs internal sizing to accommodate this many elements,
63      * given the specified load factor.
64      * @param loadFactor the load factor (table density) for
65      * establishing the initial table size
66      * @param concurrencyLevel the estimated number of concurrently
67      * updating threads. The implementation may use this value as
68      * a sizing hint.
69      * @throws IllegalArgumentException if the initial capacity is
70      * negative or the load factor or concurrencyLevel are
71      * nonpositive
72      */
73     public ConcurrentHashMap(int initialCapacity,
74                              float loadFactor, int concurrencyLevel) {
75         if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0)
76             throw new IllegalArgumentException();
77         if (initialCapacity < concurrencyLevel)   // Use at least as many bins
78             initialCapacity = concurrencyLevel;   // as estimated threads
79         long size = (long)(1.0 + (long)initialCapacity / loadFactor);
80         int cap = (size >= (long)MAXIMUM_CAPACITY) ?
81             MAXIMUM_CAPACITY : tableSizeFor((int)size);
82         this.sizeCtl = cap;
83     }

1 private static final int tableSizeFor(int c) {
2         int n = c - 1;
3         n |= n >>> 1;
4         n |= n >>> 2;
5         n |= n >>> 4;
6         n |= n >>> 8;
7         n |= n >>> 16;
8         return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
9     }

 1 /*
 2      * 当添加一对键值对的时候，首先会去判断保存这些键值对的数组是不是初始化了，
 3      * 如果没有的话就初始化数组
 4      *  然后通过计算hash值来确定放在数组的哪个位置
 5      * 如果这个位置为空则直接添加，如果不为空的话，则取出这个节点来
 6      * 如果取出来的节点的hash值是MOVED(-1)的话，则表示当前正在对这个数组进行扩容，复制到新的数组，则当前线程也去帮助复制
 7      * 最后一种情况就是，如果这个节点，不为空，也不在扩容，则通过synchronized来加锁，进行添加操作
 8      *    然后判断当前取出的节点位置存放的是链表还是树
 9      *    如果是链表的话，则遍历整个链表，直到取出来的节点的key来个要放的key进行比较，如果key相等，并且key的hash值也相等的话，
10      *          则说明是同一个key，则覆盖掉value，否则的话则添加到链表的末尾
11      *    如果是树的话，则调用putTreeVal方法把这个元素添加到树中去
12      *  最后在添加完成之后，会判断在该节点处共有多少个节点（注意是添加前的个数），如果达到8个以上了的话，
13      *  则调用treeifyBin方法来尝试将处的链表转为树，或者扩容数组
14      */
15     final V putVal(K key, V value, boolean onlyIfAbsent) {
16         if (key == null || value == null) throw new NullPointerException();//K,V都不能为空，否则的话跑出异常
17         int hash = spread(key.hashCode());    //取得key的hash值
18         int binCount = 0;    //用来计算在这个节点总共有多少个元素，用来控制扩容或者转移为树
19         for (Node<K,V>[] tab = table;;) {    //
20             Node<K,V> f; int n, i, fh;
21             if (tab == null || (n = tab.length) == 0)    
22                 tab = initTable();    //第一次put的时候table没有初始化，则初始化table
23             else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {    //通过哈希计算出一个表中的位置因为n是数组的长度，所以(n-1)&hash肯定不会出现数组越界
24                 if (casTabAt(tab, i, null,        //如果这个位置没有元素的话，则通过cas的方式尝试添加，注意这个时候是没有加锁的
25                              new Node<K,V>(hash, key, value, null)))        //创建一个Node添加到数组中区，null表示的是下一个节点为空
26                     break;                   // no lock when adding to empty bin
27             }
28             /*
29              * 如果检测到某个节点的hash值是MOVED，则表示正在进行数组扩张的数据复制阶段，
30              * 则当前线程也会参与去复制，通过允许多线程复制的功能，一次来减少数组的复制所带来的性能损失
31              */
32             else if ((fh = f.hash) == MOVED)    
33                 tab = helpTransfer(tab, f);
34             else {
35                 /*
36                  * 如果在这个位置有元素的话，就采用synchronized的方式加锁，
37                  *     如果是链表的话(hash大于0)，就对这个链表的所有元素进行遍历，
38                  *         如果找到了key和key的hash值都一样的节点，则把它的值替换到
39                  *         如果没找到的话，则添加在链表的最后面
40                  *  否则，是树的话，则调用putTreeVal方法添加到树中去
41                  *  
42                  *  在添加完之后，会对该节点上关联的的数目进行判断，
43                  *  如果在8个以上的话，则会调用treeifyBin方法，来尝试转化为树，或者是扩容
44                  */
45                 V oldVal = null;
46                 synchronized (f) {
47                     if (tabAt(tab, i) == f) {        //再次取出要存储的位置的元素，跟前面取出来的比较
48                         if (fh >= 0) {                //取出来的元素的hash值大于0，当转换为树之后，hash值为-2
49                             binCount = 1;            
50                             for (Node<K,V> e = f;; ++binCount) {    //遍历这个链表
51                                 K ek;
52                                 if (e.hash == hash &&        //要存的元素的hash，key跟要存储的位置的节点的相同的时候，替换掉该节点的value即可
53                                     ((ek = e.key) == key ||
54                                      (ek != null && key.equals(ek)))) {
55                                     oldVal = e.val;
56                                     if (!onlyIfAbsent)        //当使用putIfAbsent的时候，只有在这个key没有设置值得时候才设置
57                                         e.val = value;
58                                     break;
59                                 }
60                                 Node<K,V> pred = e;
61                                 if ((e = e.next) == null) {    //如果不是同样的hash，同样的key的时候，则判断该节点的下一个节点是否为空，
62                                     pred.next = new Node<K,V>(hash, key,        //为空的话把这个要加入的节点设置为当前节点的下一个节点
63                                                               value, null);
64                                     break;
65                                 }
66                             }
67                         }
68                         else if (f instanceof TreeBin) {    //表示已经转化成红黑树类型了
69                             Node<K,V> p;
70                             binCount = 2;
71                             if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,    //调用putTreeVal方法，将该元素添加到树中去
72                                                            value)) != null) {
73                                 oldVal = p.val;
74                                 if (!onlyIfAbsent)
75                                     p.val = value;
76                             }
77                         }
78                     }
79                 }
80                 if (binCount != 0) {
81                     if (binCount >= TREEIFY_THRESHOLD)    //当在同一个节点的数目达到8个的时候，则扩张数组或将给节点的数据转为tree
82                         treeifyBin(tab, i);    
83                     if (oldVal != null)
84                         return oldVal;
85                     break;
86                 }
87             }
88         }
89         addCount(1L, binCount);    //计数
90         return null;
91     }

1 static final int spread(int h) {
2     return (h ^ (h >>> 16)) & HASH_BITS;
3 }

 1    /**
 2      * 初始化数组table，
 3      * 如果sizeCtl小于0，说明别的数组正在进行初始化，则让出执行权
 4      * 如果sizeCtl大于0的话，则初始化一个大小为sizeCtl的数组
 5      * 否则的话初始化一个默认大小(16)的数组
 6      * 然后设置sizeCtl的值为数组长度的3/4
 7      */
 8     private final Node<K,V>[] initTable() {
 9         Node<K,V>[] tab; int sc;
10         while ((tab = table) == null || tab.length == 0) {    //第一次put的时候，table还没被初始化，进入while
11             if ((sc = sizeCtl) < 0)                            //sizeCtl初始值为0，当小于0的时候表示在别的线程在初始化表或扩展表
12                 Thread.yield(); // lost initialization race; just spin
13             else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {    //SIZECTL：表示当前对象的内存偏移量，sc表示期望值，-1表示要替换的值，设定为-1表示要初始化表了
14                 try {
15                     if ((tab = table) == null || tab.length == 0) {
16                         int n = (sc > 0) ? sc : DEFAULT_CAPACITY;        //指定了大小的时候就创建指定大小的Node数组，否则创建指定大小(16)的Node数组
17                         @SuppressWarnings("unchecked")
18                         Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
19                         table = tab = nt;
20                         sc = n - (n >>> 2);
21                     }
22                 } finally {
23                     sizeCtl = sc;            //初始化后，sizeCtl长度为数组长度的3/4
24                 }
25                 break;
26             }
27         }
28         return tab;
29     }

 1 final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) {
 2     Node<K,V>[] nextTab; int sc;
 3     if (tab != null && (f instanceof ForwardingNode) &&
 4         (nextTab = ((ForwardingNode<K,V>)f).nextTable) != null) {
 5         int rs = resizeStamp(tab.length);
 6         while (nextTab == nextTable && table == tab &&
 7                (sc = sizeCtl) < 0) {
 8             if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
 9                 sc == rs + MAX_RESIZERS || transferIndex <= 0)
10                 break;
11             if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {
12                 transfer(tab, nextTab);
13                 break;
14             }
15         }
16         return nextTab;
17     }
18     return table;
19 }
20 
21 static final int resizeStamp(int n) {
22     return Integer.numberOfLeadingZeros(n) | (1 << (RESIZE_STAMP_BITS - 1));
23 }

 1 /**
 2  * Adds to count, and if table is too small and not already
 3  * resizing, initiates transfer. If already resizing, helps
 4  * perform transfer if work is available.  Rechecks occupancy
 5  * after a transfer to see if another resize is already needed
 6  * because resizings are lagging additions.
 7  *
 8  * @param x the count to add
 9  * @param check if <0, don‘t check resize, if <= 1 only check if uncontended
10  */
11 private final void addCount(long x, int check) {
12     // check,即链表或红黑树的节点数，<0不检查是否正在扩容， 
13     // <=1仅检查是否存在竞争，没有竞争则直接返回
14     CounterCell[] as; long b, s;
15     // 如果首次执行addCount，并且尝试用CAS对baseCount计数失败，表示有竞争，则执行如下操作。
16     // 或者非首次addCount，也执行如下的操作
17     if ((as = counterCells) != null ||
18         !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
19         CounterCell a; long v; int m;
20         boolean uncontended = true;
21         if (as == null || (m = as.length - 1) < 0 ||
22             (a = as[ThreadLocalRandom.getProbe() & m]) == null ||
23             !(uncontended =
24               U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
25             fullAddCount(x, uncontended);
26             return;
27         }
28         if (check <= 1)
29             return;
30         s = sumCount();
31     }
32     if (check >= 0) {
33         Node<K,V>[] tab, nt; int n, sc;
34         while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
35                (n = tab.length) < MAXIMUM_CAPACITY) {
36             int rs = resizeStamp(n);
37             if (sc < 0) {
38                 if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
39                     sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
40                     transferIndex <= 0)
41                     break;
42                 if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
43                     transfer(tab, nt);
44             }
45             else if (U.compareAndSwapInt(this, SIZECTL, sc,
46                                          (rs << RESIZE_STAMP_SHIFT) + 2))
47                 transfer(tab, null);
48             s = sumCount();
49         }
50     }
51 }
52 // sumCount方法
53 final long sumCount() {
54     CounterCell[] as = counterCells; CounterCell a;
55     long sum = baseCount;
56     if (as != null) {
57         for (int i = 0; i < as.length; ++i) {
58             if ((a = as[i]) != null)
59                 sum += a.value;
60         }
61     }
62     return sum;
63 }

 1 public int size() {
 2     long n = sumCount();
 3     return ((n < 0L) ? 0 :
 4             (n > (long)Integer.MAX_VALUE) ? Integer.MAX_VALUE :
 5             (int)n);
 6 }
 7 // sumCount方法
 8 final long sumCount() {
 9     CounterCell[] as = counterCells; CounterCell a;
10     long sum = baseCount;
11     if (as != null) {
12         for (int i = 0; i < as.length; ++i) {
13             if ((a = as[i]) != null)
14                 sum += a.value;
15         }
16     }
17     return sum;
18 }