//以默認(rèn)參數(shù)為例initalCapacity=16，loadFactor=0.75，concurrencyLevel=16 
public ConcurrentHashMap(int initalCapacity, float loadFactor, int concurrencyLevel) { 
　　if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0) 
　　　　throw new IllegalArgumentException(); 
　　if (concurrencyLevel > MAX_SEGMENTS) 
　　　　concurrencyLevel = MAX_SEGMENTS; 
　　int sshift = 0; 
　　int ssize = 1;//segment數(shù)組長度 
　　while (ssize < concurrencyLevel) { 
　　　　++sshift; 
　　　　ssize <= 1; 
　　}//經(jīng)過ssize左移4位后，ssize=16,ssift=4 
/*segmentShift用于參與散列運(yùn)算的位數(shù)，segmentMask是散列運(yùn)算的掩碼，這里有關(guān)的散列函數(shù)運(yùn)算和HashMap有類似之處*/ 
　　this.segmentShift = 32 – ssift;//段偏移量segmentShift=28 
　　this.segmentMask = ssize – 1;//段掩碼segmentMask=15（1111） 
　　if (initialCapacity > MAXIMUM_CAPACITY) 
　　　　initialCapacity = MAXIMUM_CAPACITY; 
　　int c = initialCapacity / ssize;//c = 1 
　　if (c * ssize < initialCapacity) 
　　　　++c; 
　　int cap = MIN_SEGMENT_TABLE_CAPACITY;//MIN_SEGMENT_TABLE_CAPACITY=2 
　　while (cap < c)//cap = 2, c = 1，false 
 　　cap <<= 1;//cap是segment里HashEntry數(shù)組的長度，最小為2 
/*創(chuàng)建segments數(shù)組和segment[0]*/ 
　　Segment<K,V> s0 = new Segment<K,V>(loadFactor, (int)(cap * loadFactor), (HashEntry<K,V>[]) new HashEntry[cap]);//參數(shù)意為：負(fù)載因子=1，數(shù)據(jù)容量=(int)(2 * 0.75)=1，總?cè)萘?2，故每個(gè)Segment的HashEntry總?cè)萘繛?，實(shí)際數(shù)據(jù)容量為1 
　　Segment<K,V> ss = (Segment<K,V>[])new Segment[ssize];//segments數(shù)組大小為16 
　　UNSAFE.putOrderedObject(ss, SBASE, s0); 
　　this.segments = ss; 
}

//ConcurrentHashMap#put 
public V put(K key, V value) { 
　　Segment<K,V> s; 
　　if (value == null) 
　　　　throw new NullPointerException(); 
　　int hash = hash(key);//根據(jù)散列函數(shù)，計(jì)算出key值的散列值 
　　int j = (hash >>> segmentShift) & segmentMask;//這個(gè)操作就是定位Segment的數(shù)組下標(biāo)，jdk1.7之前是segmentFor返回Segment，1.7之后直接就取消了這個(gè)方法，直接計(jì)算數(shù)組下標(biāo)，然后通過偏移量底層操作獲取Segment 
　　if ((s = (Segment<K,V>)UNSAFE.getObject   // nonvolatile; recheck 
　　　　　　(segments, (j << SSHIFT) + SBASE)) == null) // in ensureSegment 
　　　　s = ensureSegment(j);//通過便宜量定位不到就調(diào)用ensureSegment方法定位Segment 
　　return s.put(key, hash, value, false); 
}

//Segment#put 
final V put(K key, int hash, V value, boolean onlyIfAbsent) { 
　　HashEntry<K,V> node = tryLock() ? null : scanAndLockForPut(key, hash, value);//非阻塞獲取鎖，獲取成功node=null，失敗 
　　V oldValue; 
　　try { 
　　　　HashEntry<K,V>[] tab = table;//Segment對(duì)應(yīng)的HashEntry數(shù)組長度 
　　　　int index = (tab.length - 1) & hash; 
　　　　HashEntry<K,V> first = entryAt(tab, index);//獲取HashEntry數(shù)組的第一個(gè)值 
　　　　for (HashEntry<K,V> e = first;;) { 
　　　　　　if (e != null) {//HashEntry數(shù)組已經(jīng)存在值 
　　　　　　　　K k; 
　　　　　　　　if ((k = e.key) == key || (e.hash == hash && key.equals(k))) {//key值和hash值都相等，則直接替換舊值 
　　　　　　　　　　oldValue = e.value; 
　　　　　　　　　　if (!onlyIfAbsent) { 
　　　　　　　　　　　　e.value = value; 
　　　　　　　　　　　　++modCount; 
　　　　　　　　　　} 
　　　　　　　　　　break; 
　　　　　　　　} 
　　　　　　　　e = e.next;//不是同一個(gè)值則繼續(xù)遍歷，直到找到相等的key值或者為null的HashEntry數(shù)組元素 
　　　　　　} 
　　　　　　else {//HashEntry數(shù)組中的某個(gè)位置元素為null 
　　　　　　　　if (node != null) 
　　　　　　　　　　node.setNext(first);//將新加入節(jié)點(diǎn)（key）的next引用指向HashEntry數(shù)組第一個(gè)元素 
　　　　　　　　else//已經(jīng)獲取到了Segment鎖 
　　　　　　　　　　node = new HashEntry<K,V>(hash, key, value, first) 
　　　　　　　　int c = count + 1; 
　　　　　　　　if (c > threshold && tab.lenth < MAXIUM_CAPACITY)//插入前先判斷是否擴(kuò)容，ConcurrentHashMap擴(kuò)容與HashMap不同，ConcurrentHashMap只擴(kuò)Segment的容量，HashMap則是整個(gè)擴(kuò)容 
　　　　　　　　　　rehash(node); 
　　　　　　　　else 
　　　　　　　　　　setEntryAt(tab, index, node);//設(shè)置為頭節(jié)點(diǎn) 
　　　　　　　　++modCount;//總?cè)萘?
　　　　　　　　count = c; 
　　　　　　　　oldValue = null; 
　　　　　　　　break; 
　　　　　　} 
　　　　　} 
　　} finally { 
　　　　unlock(); 
　　} 
　　return oldValue; 
}