8.并发容器ConcurrentHashMap#put方法解析

 1 //以默认参数为例initalCapacity=16，loadFactor=0.75，concurrencyLevel=16 
 2 public ConcurrentHashMap(int initalCapacity, float loadFactor, int concurrencyLevel) { 
 3 　　if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0) 
 4 　　　　throw new IllegalArgumentException(); 
 5 　　if (concurrencyLevel > MAX_SEGMENTS) 
 6 　　　　concurrencyLevel = MAX_SEGMENTS; 
 7 　　int sshift = 0; 
 8 　　int ssize = 1;//segment数组长度 
 9 　　while (ssize < concurrencyLevel) { 
10 　　　　++sshift; 
11 　　　　ssize <= 1; 
12 　　}//经过ssize左移4位后，ssize=16,ssift=4 
13 /*segmentShift用于参与散列运算的位数，segmentMask是散列运算的掩码，这里有关的散列函数运算和HashMap有类似之处*/ 
14 　　this.segmentShift = 32 – ssift;//段偏移量segmentShift=28 
15 　　this.segmentMask = ssize – 1;//段掩码segmentMask=15（1111） 
16 　　if (initialCapacity > MAXIMUM_CAPACITY) 
17 　　　　initialCapacity = MAXIMUM_CAPACITY; 
18 　　int c = initialCapacity / ssize;//c = 1 
19 　　if (c * ssize < initialCapacity) 
20 　　　　++c; 
21 　　int cap = MIN_SEGMENT_TABLE_CAPACITY;//MIN_SEGMENT_TABLE_CAPACITY=2 
22 　　while (cap < c)//cap = 2, c = 1，false 
23     　　cap <<= 1;//cap是segment里HashEntry数组的长度，最小为2 
24 /*创建segments数组和segment[0]*/ 
25 　　Segment<K,V> s0 = new Segment<K,V>(loadFactor, (int)(cap * loadFactor), (HashEntry<K,V>[]) new HashEntry[cap]);//参数意为：负载因子=1，数据容量=(int)(2 * 0.75)=1，总容量=2，故每个Segment的HashEntry总容量为2，实际数据容量为1 
26 　　Segment<K,V> ss = (Segment<K,V>[])new Segment[ssize];//segments数组大小为16 
27 　　UNSAFE.putOrderedObject(ss, SBASE, s0); 
28 　　this.segments = ss; 
29 } 

 1 //ConcurrentHashMap#put 
 2 public V put(K key, V value) { 
 3 　　Segment<K,V> s; 
 4 　　if (value == null) 
 5 　　　　throw new NullPointerException(); 
 6 　　int hash = hash(key);//根据散列函数，计算出key值的散列值 
 7 　　int j = (hash >>> segmentShift) & segmentMask;//这个操作就是定位Segment的数组下标，jdk1.7之前是segmentFor返回Segment，1.7之后直接就取消了这个方法，直接计算数组下标，然后通过偏移量底层操作获取Segment 
 8 　　if ((s = (Segment<K,V>)UNSAFE.getObject          // nonvolatile; recheck 
 9 　　　　　　(segments, (j << SSHIFT) + SBASE)) == null) //  in ensureSegment 
10 　　　　s = ensureSegment(j);//通过便宜量定位不到就调用ensureSegment方法定位Segment 
11 　　return s.put(key, hash, value, false); 
12 } 

 1 //Segment#put 
 2 final V put(K key, int hash, V value, boolean onlyIfAbsent) { 
 3 　　HashEntry<K,V> node = tryLock() ? null : scanAndLockForPut(key, hash, value);//非阻塞获取锁，获取成功node=null，失败 
 4 　　V oldValue; 
 5 　　try { 
 6 　　　　HashEntry<K,V>[] tab = table;//Segment对应的HashEntry数组长度 
 7 　　　　int index = (tab.length - 1) & hash; 
 8 　　　　HashEntry<K,V> first = entryAt(tab, index);//获取HashEntry数组的第一个值 
 9 　　　　for (HashEntry<K,V> e = first;;) { 
10 　　　　　　if (e != null) {//HashEntry数组已经存在值 
11 　　　　　　　　K k; 
12 　　　　　　　　if ((k = e.key) == key || (e.hash == hash && key.equals(k))) {//key值和hash值都相等，则直接替换旧值 
13 　　　　　　　　　　oldValue = e.value; 
14 　　　　　　　　　　if (!onlyIfAbsent) { 
15 　　　　　　　　　　　　e.value = value; 
16 　　　　　　　　　　　　++modCount; 
17 　　　　　　　　　　} 
18 　　　　　　　　　　break; 
19 　　　　　　　　} 
20 　　　　　　　　e = e.next;//不是同一个值则继续遍历，直到找到相等的key值或者为null的HashEntry数组元素 
21 　　　　　　} 
22 　　　　　　else {//HashEntry数组中的某个位置元素为null 
23 　　　　　　　　if (node != null) 
24 　　　　　　　　　　node.setNext(first);//将新加入节点（key）的next引用指向HashEntry数组第一个元素 
25 　　　　　　　　else//已经获取到了Segment锁 
26 　　　　　　　　　　node = new HashEntry<K,V>(hash, key, value, first) 
27 　　　　　　　　int c = count + 1; 
28 　　　　　　　　if (c > threshold && tab.lenth < MAXIUM_CAPACITY)//插入前先判断是否扩容，ConcurrentHashMap扩容与HashMap不同，ConcurrentHashMap只扩Segment的容量，HashMap则是整个扩容 
29 　　　　　　　　　　rehash(node); 
30 　　　　　　　　else 
31 　　　　　　　　　　setEntryAt(tab, index, node);//设置为头节点 
32 　　　　　　　　++modCount;//总容量 
33 　　　　　　　　count = c; 
34 　　　　　　　　oldValue = null; 
35 　　　　　　　　break; 
36 　　　　　　} 
37 　　　　　} 
38 　　} finally { 
39 　　　　unlock(); 
40 　　} 
41 　　return oldValue; 
42 }