Jdk1.7下ConcurrentHashMap常用方法的源码分析

1.首先从下面这段代码的看一下它的构造方法

 ConcurrentHashMap<String, Object> map = new ConcurrentHashMap<>();
 map.put("123", "1");
 map.put("234", "2");
 System.out.println(map.get("123"));
 System.out.println(map.size());

2.点击进入到构造方法中

 public ConcurrentHashMap() {
   // 默认容量，默认加载因子，默认并发级别
   this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);
 }

其中DEFAULT_INITIAL_CAPACITY表示map的容量，DEFAULT_LOAD_FACTOR表示加载因子，DEFAULT_CONCURRENCY_LEVEL表示的是Segment大小。

3.继续点击进入到方法中

	@SuppressWarnings("unchecked")
    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;
        while (ssize < concurrencyLevel) {
            ++sshift;
            ssize <<= 1;
        }
        this.segmentShift = 32 - sshift;
        // 确定Segment数组的大小
        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内部的HashEntry数组的大小
        while (cap < c)
            cap <<= 1;
        // create segments and segments[0]
        // 初始化一个s0
        Segment<K,V> s0 =
            new Segment<K,V>(loadFactor, (int)(cap * loadFactor),
                             (HashEntry<K,V>[])new HashEntry[cap]);
        // 创建一个Segment数组
        Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize];
        // 并将上面创建的s0放在Segment数组的第一个位置
        UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]
        this.segments = ss;
    }

上面代码初始化之后的效果图如下：

4.下面来看一下put方法

 public V put(K key, V value) {
        Segment<K,V> s;
        // 做一些value判断是否为null操作
        if (value == null)
            throw new NullPointerException();
        // 计算key对应的hash值，并计算出key在Segment数组中对应的数组下标j
        int hash = hash(key);
        int j = (hash >>> segmentShift) & segmentMask;
        // 取得Segment[j]位置的值是否为null，然后并初始化操作
        if ((s = (Segment<K,V>)UNSAFE.getObject          // nonvolatile; recheck
             (segments, (j << SSHIFT) + SBASE)) == null) //  in ensureSegment
            s = ensureSegment(j);
        // put进入值
        return s.put(key, hash, value, false);
}

5.继续点击进入到ensureSegment方法中来

	@SuppressWarnings("unchecked")
    private Segment<K,V> ensureSegment(int k) {
        final Segment<K,V>[] ss = this.segments;
        long u = (k << SSHIFT) + SBASE; // raw offset
        Segment<K,V> seg;
        // 第一次判断u位置的Segment是否为空
        if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u)) == null) {
        	// 利用之前ss[0]的属性创建一个新的Segment
            Segment<K,V> proto = ss[0]; // use segment 0 as prototype
            int cap = proto.table.length;
            float lf = proto.loadFactor;
            int threshold = (int)(cap * lf);
            HashEntry<K,V>[] tab = (HashEntry<K,V>[])new HashEntry[cap];
             // 第二次判断u位置的Segment是否为空
            if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))
                == null) { // recheck
                // 创建一个新的Segment
                Segment<K,V> s = new Segment<K,V>(lf, threshold, tab);
                // 第三次判断u位置的Segment是否为空
                while ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))
                       == null) {
                    // 通过cas操作判断u的位置是否为Null,为null的话就将s赋值给seg，并返回
                    if (UNSAFE.compareAndSwapObject(ss, u, null, seg = s))
                        break;
                }
            }
        }
        return seg;
    }

6.然后再进入到s.put(key, hash, value, false);代码中的put方法中来

final V put(K key, int hash, V value, boolean onlyIfAbsent) {
			// 首先会尝试获取锁，如果获取失败肯定就有其他线程存在竞争，则利用 scanAndLockForPut() 自旋获取锁。
			// 其中尝试自旋获取锁。如果重试的次数达到了 MAX_SCAN_RETRIES 则改为阻塞锁获取，保证能获取成功。这里在获取锁的过程中会创建node
            HashEntry<K,V> node = tryLock() ? null :
                scanAndLockForPut(key, hash, value);
            V oldValue;
            try {
                HashEntry<K,V>[] tab = table;
                // 先获取key在segement内部的hashEntry数组对应的下标
                int index = (tab.length - 1) & hash;
                // 获取key对应的值
                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 {
                    	// 如果之前获取锁的过程中创建了一个node，则使用头插法插入元素
                        if (node != null)
                            node.setNext(first);
                        // 如果之前的操作都没创建一个node节点，则创建一个新的node，并使用头插法插入元素
                        else
                            node = new HashEntry<K,V>(hash, key, value, first);
                        int c = count + 1;
                        // 判断是否需要扩容
                        if (c > threshold && tab.length < MAXIMUM_CAPACITY)
                        	// 这里的扩容是在segement内部对数组进行扩容为原来两倍
                            rehash(node);
                        // 设置对应位置上的元素
                        else
                            setEntryAt(tab, index, node);
                        ++modCount;
                        count = c;
                        oldValue = null;
                        break;
                    }
                }
            } finally {
            	// 释放锁
                unlock();
            }
            return oldValue;
}

上面操作完的效果图如下：

7.继续点击get方法中来

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;
        if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&
            (tab = s.table) != null) {
            // 然后再遍历segments[u]位置上HashEntry数组，找出key相同的node并返回对应的value
            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;
}

8.再来看一下size方法

	public int size() {
        // Try a few times to get accurate count. On failure due to
        // continuous async changes in table, resort to locking.
        final Segment<K,V>[] segments = this.segments;
        int size;
        boolean overflow; // true if size overflows 32 bits
        long sum;         // sum of modCounts
        long last = 0L;   // previous sum
        int retries = -1; // first iteration isn't retry
        try {
            for (;;) {
            	// 这里是遍历segments数组并给每一段加锁
                if (retries++ == RETRIES_BEFORE_LOCK) {
                    for (int j = 0; j < segments.length; ++j)
                        ensureSegment(j).lock(); // force creation
                }
                sum = 0L;
                size = 0;
                overflow = false;
                // 分段计算
                for (int j = 0; j < segments.length; ++j) {
                    Segment<K,V> seg = segmentAt(segments, j);
                    if (seg != null) {
                        sum += seg.modCount;
                        int c = seg.count;
                        if (c < 0 || (size += c) < 0)
                            overflow = true;
                    }
                }
                if (sum == last)
                    break;
                last = sum;
            }
        } finally {
            if (retries > RETRIES_BEFORE_LOCK) {
            	// 这里是遍历segments数组并给每一段释放锁
                for (int j = 0; j < segments.length; ++j)
                    segmentAt(segments, j).unlock();
            }
        }
        return overflow ? Integer.MAX_VALUE : size;
}