ConcurrentHashMap1.7源码详细解读

1.首先看构造函数

public ConcurrentHashMap() {
    this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);
}

其中 DEFAULT_INITIAL_CAPACITY 默认16，为初始的容量，

  DEFAULT_LOAD_FACTOR        加载因子0.75

  DEFAULT_CONCURRENCY_LEVEL   并发级别默认16 ，这个并发级别代表16个Segment

ConcurrentHashMap 有16个Segment 当我们.put() 一个数据的时候，要进行三步计算hash值，

第一步先确定保存到哪一个Segment 中，然后 就和hashMap一样保存到 哪个数数组，然后就是数组中产生Hash冲突的时候保存的链表。其中16个Segment是固定的。

构造函数的具体方法

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) {//concurrencyLevel=16
        ++sshift;
        ssize <<= 1;//表示ssize每次平方操作
    }
    //执行后sshift =4  这里可以debug一下就可以知道
    this.segmentShift = 32 - sshift;//32-4 28
    this.segmentMask = ssize - 1;// 16-1 =15
    if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;
    int c = initialCapacity / ssize;//16除以16=1
    if (c * ssize < initialCapacity)
        ++c;
    int cap = MIN_SEGMENT_TABLE_CAPACITY;//MIN_SEGMENT_TABLE_CAPACI=2
    while (cap < c)
        cap <<= 1;
    //当执行构造函数的时候 首先会在segments数组的第0号位      
   //置初始化一个Segment对象 以便其它位置需要的时候拿过来直接赋值。
    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); //这一步就是通过调用内存直接赋值，可以理解为
    //ss[0]=s0;
    this.segments = ss;
}

二、put方法

public V put(K key, V value) {
    Segment<K,V> s;
    if (value == null)
        throw new NullPointerException();
    int hash = hash(key);//计算hash值
    int j = (hash >>> segmentShift) & segmentMask;  //这一步可以理解 通过计算得到j这样定位那一个segment
    if ((s = (Segment<K,V>)UNSAFE.getObject          
         (segments, (j << SSHIFT) + SBASE)) == null) //在segments数组中获取到segment对象
        s = ensureSegment(j);//判断一下 如果拿到s=null这把刚才的第0号位置赋值给他
    return s.put(key, hash, value, false);
}

ensureSegment方法：

private Segment<K,V> ensureSegment(int k) {
    final Segment<K,V>[] ss = this.segments;
    long u = (k << SSHIFT) + SBASE; // 计算位置，在重复计算一次和上边一样
    Segment<K,V> seg;
    if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u)) == null) {
        Segment<K,V> proto = ss[0]; // 把0号位置拿出来
        int cap = proto.table.length;
        float lf = proto.loadFactor;
        int threshold = (int)(cap * lf);
        HashEntry<K,V>[] tab = (HashEntry<K,V>[])new HashEntry[cap];//初始化HashEntry
        if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))
            == null) {//在主内存中在中重新检查下，是否等于null,因为为了并发安全
            Segment<K,V> s = new Segment<K,V>(lf, threshold, tab);
            while ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))
                   == null) {//自旋检查，确定等于null在赋值
                if (UNSAFE.compareAndSwapObject(ss, u, null, seg = s))
                    break;
            }
        }
    }
    return seg;
}

put方法：

  tryLock() 当获取不到锁的时候返回false,获取到锁返回true ,但不阻塞，
  lock()获取不到锁会阻塞，

第一种情况假如tryLock() 返回true,即线程获取到锁，返回true 即

HashEntry<K,V> node =null,

第二种情况是，多个线程访问其中一个拿到锁，而其它的线程没有拿到锁，没到到锁的线程会走

scanAndLockForPut（）方法。

final V put(K key, int hash, V value, boolean onlyIfAbsent) {

    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);//获取table中链表第一个HashEntry
        for (HashEntry<K,V> e = first;;) {
            if (e != null) {
                K k;
                if ((k = e.key) == key ||
                    (e.hash == hash && key.equals(k))) {//执行修改操作，也就是put("a","123") 修改成put("a","321") 
                    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);//如果node =null这直接初始化一个HashEntry存值之后放入链表中。这个节点的下一个指针指向first,采用头插入法
                int c = count + 1;
                if (c > threshold && tab.length < MAXIMUM_CAPACITY)
                    rehash(node);//扩容
                else
                    setEntryAt(tab, index, node);//存放链表中
                ++modCount;
                count = c;
                oldValue = null;
                break;
            }
        }
    } finally {
        unlock();
    }
    return oldValue;
}

 

scanAndLockForPut方法分析：即没有拿到锁的线程会走到这个方法

private HashEntry<K,V> scanAndLockForPut(K key, int hash, V value) {
    HashEntry<K,V> first = entryForHash(this, hash);
    HashEntry<K,V> e = first;
    HashEntry<K,V> node = null;
    int retries = -1; // 这个-1 挺有意思 
    while (!tryLock()) {//再检查下 是否能获取到锁。
        HashEntry<K,V> f; 
        if (retries < 0) {
            //第一次循环肯定走这里，因为retries  =-1
            if (e == null) {
                if (node == null)
                    node = new HashEntry<K,V>(hash, key, value, null);//链表遍历到最后一个，表示没有key值相同的情况，初始化一个HashEntry 赋值提前准备好。
                    retries = 0;
            }
            else if (key.equals(e.key)) //表示找到了同一个key值。
                retries = 0;//赋值0 跳出ifretries < 0 的循环
            else
                e = e.next;//继续往下遍历链表
        }
        else if (++retries > MAX_SCAN_RETRIES) {//MAX_SCAN_RETRIES =64也就是最多循环64次
            lock();//如果超过64次了调用lock锁，一致等到拿到锁才break,期间一致阻塞等待
            break;
        }

//f = entryForHash(this, hash)) != first 这一段代码的意思是，拿到锁的线程把first修改了，所以retries=-1 又从新执行 if(retries < 0) 的逻辑。
        else if ((retries & 1) == 0 &&
                 (f = entryForHash(this, hash)) != first) {
            e = first = f; //从新赋值因为first改变了
            retries = -1;
        }
    }
    return node;
}