使用Java如何實現ConcurrentHashMap#put并發容器

//以默認參數為例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數組長度 
　　while (ssize < concurrencyLevel) { 
　　　　++sshift; 
　　　　ssize <= 1; 
　　}//經過ssize左移4位后，ssize=16,ssift=4 
/*segmentShift用于參與散列運算的位數，segmentMask是散列運算的掩碼，這里有關的散列函數運算和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數組的長度，最小為2 
/*創建segments數組和segment[0]*/ 
　　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 
　　Segment<K,V> ss = (Segment<K,V>[])new Segment[ssize];//segments數組大小為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);//根據散列函數，計算出key值的散列值 
　　int j = (hash >>> segmentShift) & segmentMask;//這個操作就是定位Segment的數組下標，jdk1.7之前是segmentFor返回Segment，1.7之后直接就取消了這個方法，直接計算數組下標，然后通過偏移量底層操作獲取Segment 
　　if ((s = (Segment<K,V>)UNSAFE.getObject   // nonvolatile; recheck 
　　　　　　(segments, (j << SSHIFT) + SBASE)) == null) // in ensureSegment 
　　　　s = ensureSegment(j);//通過便宜量定位不到就調用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對應的HashEntry數組長度 
　　　　int index = (tab.length - 1) & hash; 
　　　　HashEntry<K,V> first = entryAt(tab, index);//獲取HashEntry數組的第一個值 
　　　　for (HashEntry<K,V> e = first;;) { 
　　　　　　if (e != null) {//HashEntry數組已經存在值 
　　　　　　　　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;//不是同一個值則繼續遍歷，直到找到相等的key值或者為null的HashEntry數組元素 
　　　　　　} 
　　　　　　else {//HashEntry數組中的某個位置元素為null 
　　　　　　　　if (node != null) 
　　　　　　　　　　node.setNext(first);//將新加入節點（key）的next引用指向HashEntry數組第一個元素 
　　　　　　　　else//已經獲取到了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);//設置為頭節點 
　　　　　　　　++modCount;//總容量 
　　　　　　　　count = c; 
　　　　　　　　oldValue = null; 
　　　　　　　　break; 
　　　　　　} 
　　　　　} 
　　} finally { 
　　　　unlock(); 
　　} 
　　return oldValue; 
}