使用Java如何實現(xiàn)ConcurrentHashMap#put并發(fā)容器

//以默認參數(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用于參與散列運算的位數(shù)，segmentMask是散列運算的掩碼，這里有關(guān)的散列函數(shù)運算和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ù)意為：負載因子=1，數(shù)據(jù)容量=(int)(2 * 0.75)=1，總?cè)萘?2，故每個Segment的HashEntry總?cè)萘繛?，實際數(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ù)，計算出key值的散列值 
　　int j = (hash >>> segmentShift) & segmentMask;//這個操作就是定位Segment的數(shù)組下標，jdk1.7之前是segmentFor返回Segment，1.7之后直接就取消了這個方法，直接計算數(shù)組下標，然后通過偏移量底層操作獲取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() &#63; null : scanAndLockForPut(key, hash, value);//非阻塞獲取鎖，獲取成功node=null，失敗 
　　V oldValue; 
　　try { 
　　　　HashEntry<K,V>[] tab = table;//Segment對應(yīng)的HashEntry數(shù)組長度 
　　　　int index = (tab.length - 1) & hash; 
　　　　HashEntry<K,V> first = entryAt(tab, index);//獲取HashEntry數(shù)組的第一個值 
　　　　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;//不是同一個值則繼續(xù)遍歷，直到找到相等的key值或者為null的HashEntry數(shù)組元素 
　　　　　　} 
　　　　　　else {//HashEntry數(shù)組中的某個位置元素為null 
　　　　　　　　if (node != null) 
　　　　　　　　　　node.setNext(first);//將新加入節(jié)點（key）的next引用指向HashEntry數(shù)組第一個元素 
　　　　　　　　else//已經(jīng)獲取到了Segment鎖 
　　　　　　　　　　node = new HashEntry<K,V>(hash, key, value, first) 
　　　　　　　　int c = count + 1; 
　　　　　　　　if (c > threshold && tab.lenth < MAXIUM_CAPACITY)//插入前先判斷是否擴容，ConcurrentHashMap擴容與HashMap不同，ConcurrentHashMap只擴Segment的容量，HashMap則是整個擴容 
　　　　　　　　　　rehash(node); 
　　　　　　　　else 
　　　　　　　　　　setEntryAt(tab, index, node);//設(shè)置為頭節(jié)點 
　　　　　　　　++modCount;//總?cè)萘?
　　　　　　　　count = c; 
　　　　　　　　oldValue = null; 
　　　　　　　　break; 
　　　　　　} 
　　　　　} 
　　} finally { 
　　　　unlock(); 
　　} 
　　return oldValue; 
}