ConcurrentHashMap_jdk1.7

public ConcurrentHashMap() {
    	// 默認Table容量爲16,默認擴容因子爲0.75，默認併發級別爲16（即分段鎖個數）
        this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);
    }    

public ConcurrentHashMap(int initialCapacity,
                             float loadFactor, int concurrencyLevel) {
        if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)
            throw new IllegalArgumentException();
        if (concurrencyLevel > MAX_SEGMENTS)
            concurrencyLevel = MAX_SEGMENTS;
        // Find power-of-two sizes best matching arguments
        int sshift = 0;
        int ssize = 1;
        // 保證Segment數組的大小，一定爲2的冪，例如用戶設置併發度爲17，則實際Segment數組大小則爲32
        while (ssize < concurrencyLevel) {
            ++sshift;
            ssize <<= 1;
        }
		/*用於定位元素所在segment。segmentShift表示偏移位數，通過前面的int類型的位的描述我們可以得知，
        int類型的數字在變大的過程中，低位總是比高位先填滿的，爲保證元素在segment級別分佈的儘量均勻，
        計算元素所在segment時，總是取hash值的高位進行計算。segmentMask作用就是爲了利用位運算中取模的操作：
        a % (Math.pow(2,n)) 等價於 a&( Math.pow(2,n)-1)*/
        this.segmentShift = 32 - sshift;
        this.segmentMask = ssize - 1;
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        int c = initialCapacity / ssize;
        if (c * ssize < initialCapacity)
            ++c;
        int cap = MIN_SEGMENT_TABLE_CAPACITY;
        // 保證每個Segment中tabel數組的大小，一定爲2的冪，初始化的三個參數取默認值時，table數組大小爲2
        while (cap < c)
            cap <<= 1;
        // 初始化Segment數組，並實際只填充Segment數組的第0個元素。
        Segment<K,V> s0 =
            new Segment<K,V>(loadFactor, (int)(cap * loadFactor),
                             (HashEntry<K,V>[])new HashEntry[cap]);
        Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize];
        UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]
        this.segments = ss;
    }

    public V get(Object key) {
        Segment<K,V> s; // manually integrate access methods to reduce overhead
        HashEntry<K,V>[] tab;
        int h = hash(key);
        // 定位segment
        long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
        // 獲取segment，獲取成功後接着獲取segment對應的tab數組        
        if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&
            (tab = s.table) != null) {
			// 定位table,依次掃描這個table元素下的的鏈表，要麼找到元素，要麼返回null。
            for (HashEntry<K,V> e = (HashEntry<K,V>) UNSAFE.getObjectVolatile
                     (tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE);
                 e != null; e = e.next) {
                K k;
                if ((k = e.key) == key || (e.hash == h && key.equals(k)))
                    return e.value;
            }
        }
        return null;
    }

    static final class HashEntry<K,V> {
        final int hash;
        final K key;
        // 用volatile關鍵字修飾，在高併發下的情況下保證取得的元素是最新的
        volatile V value;
        volatile HashEntry<K,V> next;
    }    

    public V put(K key, V value) {
        Segment<K,V> s;
        /*ConcurrentMaps不允許key、value爲null，這與數據結構是否支持併發息息相關。當ConcurrentMaps使用map.get(key)時返回爲null,
        無法判斷key是不存在還是值爲空，non-concurrent還可以再調用map.contains(key)檢查，
        但ConcurrentMaps可能再兩次調用間已經發生改變*/
        if (value == null)
            throw new NullPointerException();
        int hash = hash(key);
        int j = (hash >>> segmentShift) & segmentMask;
        if ((s = (Segment<K,V>)UNSAFE.getObject          // nonvolatile; recheck
             (segments, (j << SSHIFT) + SBASE)) == null) //  in ensureSegment
            /*首先定位segment，當這個segment在當前所在的ConcurrentMap初始化後，還爲null，
        	由ensureSegment方法負責創建並填充這個segment（填充使用CAS機制）*/
            s = ensureSegment(j);
        return s.put(key, hash, value, false);
    }    
    // 接上述s.put，即內部類static final class Segment<K,V> extends ReentrantLock的put方法
    final V put(K key, int hash, V value, boolean onlyIfAbsent) {
    		// 對Segment 加鎖
            HashEntry<K,V> node = tryLock() ? null :
                scanAndLockForPut(key, hash, value);
            V oldValue;
            try {
                HashEntry<K,V>[] tab = table;
                int index = (tab.length - 1) & hash;
                HashEntry<K,V> first = entryAt(tab, index);
                for (HashEntry<K,V> e = first;;) {
                    if (e != null) {
                        K k;
                        if ((k = e.key) == key ||
                            (e.hash == hash && key.equals(k))) {
                            oldValue = e.value;
                            if (!onlyIfAbsent) {
                            	// 找到這個元素時，覆蓋舊值，如果判斷失敗，直接返回舊值
                                e.value = value;
                                ++modCount;
                            }
                            break;
                        }
                        e = e.next;
                    }
                    else {
                        if (node != null)
                        	// 新元素往頭節點插入
                            node.setNext(first);
                        else
                            node = new HashEntry<K,V>(hash, key, value, first);
                        int c = count + 1;
                        if (c > threshold && tab.length < MAXIMUM_CAPACITY)
                        	// 如果需要擴容，則重新計算各個節點哈希值
                            rehash(node);
                        else
                        	// 新元素掛載到table數組中，在table中擁有相同哈希值的結點就形成了一個以新元素爲頭節點的鏈表
                            setEntryAt(tab, index, node);
                        ++modCount;
                        count = c;
                        oldValue = null;
                        break;
                    }
                }
            } finally {
                unlock();
            }
            return oldValue;
        }