Jdk1.7之ConcurrentHashMap源码总结

一、常见属性

1. 初始化容量

/**
 * The default initial capacity for this table,
 * used when not otherwise specified in a constructor.
 */
 //默认初始化的容量
static final int DEFAULT_INITIAL_CAPACITY = 16;

2. 加载因子

/**
 * The default load factor for this table, used when not
 * otherwise specified in a constructor.
 */
static final float DEFAULT_LOAD_FACTOR = 0.75f;

3. 并发级别

/**
 * The default concurrency level for this table, used when not
 * otherwise specified in a constructor.
 */
static final int DEFAULT_CONCURRENCY_LEVEL = 16;

二、重要方法

1. 构造方法

public ConcurrentHashMap() {
	//见图1.1 如果DEFAULT_INITIAL_CAPACITY等于32   DEFAULT_CONCURRENCY_LEVEL等于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();
   //如果concurrencyLevel 大于最大支持的并发量，则设置为MAX_SEGMENTS
   if (concurrencyLevel > MAX_SEGMENTS)
       concurrencyLevel = MAX_SEGMENTS;
   // Find power-of-two sizes best matching arguments
   int sshift = 0;
   int ssize = 1;
   //当concurrencyLevel等于16，sshift=4    2^4 = 16
   while (ssize < concurrencyLevel) {
       ++sshift;
       //左移乘2，找到里2的次幂最近的数
       ssize <<= 1;
   }
   //int类型32个bit位  32-4 = 28   put方法会用到，先这么理解
   this.segmentShift = 32 - sshift;
   //这里表示segment长度-1
   this.segmentMask = ssize - 1;
   //判断初始容量是否超过最大值
   if (initialCapacity > MAXIMUM_CAPACITY)
   	//将initialCapacity 设置为最大容量
       initialCapacity = MAXIMUM_CAPACITY;
   //如果initialCapacity 和ssize走默认值 16 , c = 1
   int c = initialCapacity / ssize;
   if (c * ssize < initialCapacity)
   	//c要向上取整
       ++c;
   //cap = 2 代表segment数组容量
   int cap = MIN_SEGMENT_TABLE_CAPACITY;
   while (cap < c)
       cap <<= 1;
   // create segments and segments[0]
   //创建一个segment对象，设置阈值cap * loadFactor
   //扩容是针对segment里的hashEntry扩容，并不是整个segment都要扩容
   Segment<K,V> s0 =
       new Segment<K,V>(loadFactor, (int)(cap * loadFactor),
                        (HashEntry<K,V>[])new HashEntry[cap]);
   //创建一个空的segment数组，这里ssize一定是2的次幂
   Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize];
   //使用CAS将创建出来的s0对象放到第0个位置，这里是为了复用segment对象，因为每个segment在首次创建时（初始化）属性都一样，后续扩容就是自己内部segment的事情了
   UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]
   this.segments = ss;
}
Segment(float lf, int threshold, HashEntry<K,V>[] tab) {
    this.loadFactor = lf;
    this.threshold = threshold;
    this.table = tab;
}

图1.1

2. ConcurrentHashMap#put方法

public V put(K key, V value) {
        Segment<K,V> s;
        //value等于null抛异常
        if (value == null)
            throw new NullPointerException();
        //根据key算出一个hash值
        int hash = hash(key);
        //segmentMask其实就是segment数组的大小-1，可以看下构造方法哪里
        //算出落在Segment数组中的位置 j
        //segmentShift默认计算出是28，可以看下构造方法哪里
        //int类型hash值右移28位，相当于保留了高4位  再进行&操作 
        //（segmentMask可以推出15由构造方法）而15二进制低4位是1,高4位与低4位相互对应，合理算出segment下标
        int j = (hash >>> segmentShift) & segmentMask;
        //如果对应segment数组中的segment对象等于null,还没有初始化，则生成一个segment对象
        if ((s = (Segment<K,V>)UNSAFE.getObject          // nonvolatile; recheck
             (segments, (j << SSHIFT) + SBASE)) == null) //  in ensureSegment
            //生成一个segment对象
            s = ensureSegment(j);
            //调用segment对象的put方法
        return s.put(key, hash, value, false);
    }

‍这里需要注意ConcurrentHashMap的key不能为null，但是hashmap是可以为null的。‍

2.1 ConcurrentHashMap#put#ensureSegment

private Segment<K,V> ensureSegment(int k) {
	//获取segment数组
    final Segment<K,V>[] ss = this.segments;
    long u = (k << SSHIFT) + SBASE; // raw offset
    Segment<K,V> seg;
    //这里多线程如果落到同一个下标，会产生竞争，所以需要进行一下判空
    if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u)) == null) {
    	//获取segment数组的第0个位置，与构造方法哪里进行对应  复用
        Segment<K,V> proto = ss[0]; // use segment 0 as prototype
        //获取第0个位置segment内部HashEntry数组大小
        int cap = proto.table.length;
        float lf = proto.loadFactor;
        int threshold = (int)(cap * lf);
        //创建segment内部的HashEntry数组，注意cap与第0个segment保持一直
        HashEntry<K,V>[] tab = (HashEntry<K,V>[])new HashEntry[cap];
        //类似double check 再次判断
        if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))
            == null) { // recheck
            //真正的创建一个Segment对象，此时还没有放到Segment数组中,只是创建
            Segment<K,V> s = new Segment<K,V>(lf, threshold, tab);
            //死循环+CAS保证刚创建的Segment对象成功放到segment数组中
            while ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))
                   == null) {
                if (UNSAFE.compareAndSwapObject(ss, u, null, seg = s))
                	//操作成功，返回
                    break;
            }
        }
    }
    return seg;
}

2.2 ConcurrentHashMap#Segment#put

final V put(K key, int hash, V value, boolean onlyIfAbsent) {
			//c尝试获取一把独占锁，因为segment继承ReentrantLock
			//获取到锁返回null,否则调用scanAndLockForPut
            HashEntry<K,V> node = tryLock() ? null :
                scanAndLockForPut(key, hash, value);
            V oldValue;
            try {
            	//获取segment内部的table
                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))) {
                            //如果存在key相同的
                            oldValue = e.value;
                            if (!onlyIfAbsent) {
                            	//不存在才更新  
                                e.value = value;
                                ++modCount;
                            }
                            break;
                        }
                        //当遍历到链表的最后一个元素，这里e = null,因为这里是死循环，所以会走到else分支
                        e = e.next;
                    }
                    else {
                    	//
                        if (node != null)
                            node.setNext(first);
                        else
                        	//对应链表上没有key,value的情况，采用头插法，创建一个新的node
                            node = new HashEntry<K,V>(hash, key, value, first);
                        //当前segment内部存放的元素+1
                        int c = count + 1;
                        //大于阈值，则rehash进行扩容，该方法是segment对象自己的，所以是内部扩容
                        if (c > threshold && tab.length < MAXIMUM_CAPACITY)
                        	//segment内部进行扩容
                            rehash(node);
                        else
                        	//CAS尝试放到数组的第i个位置
                            setEntryAt(tab, index, node);
                        ++modCount;
                        //对count赋值
                        count = c;
                        oldValue = null;
                        break;
                    }
                }
            } finally {
            	//解锁
                unlock();
            }
            //返回旧值
            return oldValue;
        }

2.2.1 Segment#put#scanAndLockForPut

//继续尝试获取锁过程中，提前构建HashEntry对象
private HashEntry<K,V> scanAndLockForPut(K key, int hash, V value) {
			//this代表当前segment对象
			//获取hash值对应下标的元素
            HashEntry<K,V> first = entryForHash(this, hash);
            HashEntry<K,V> e = first;
            HashEntry<K,V> node = null;
            //重试次数
            int retries = -1; // negative while locating node
            //遍历链表的每个结点都会再次尝试获取锁
            while (!tryLock()) {
            	//没有获取到锁的情况
                HashEntry<K,V> f; // to recheck first below
                if (retries < 0) { retries = -1
                //一开始会进到这个分支
                    if (e == null) {
                        if (node == null) // speculatively create node
                        	//创建一个node结点
                            node = new HashEntry<K,V>(hash, key, value, null);
                        //将retries 置为0，下次循环就不会进到该分支了
                        retries = 0;
                    }
                    else if (key.equals(e.key))
                    	//如果发现有相同的key，就不用创建node节点了
                    	//将retries 置为0，下次循环就不会进到该分支了
                        retries = 0;
                    else
                    	//遍历链表，直到尾结点
                        e = e.next;
                }
                //避免CPU过度消耗，达到一定重试次数后，直接阻塞式获取锁
                else if (++retries > MAX_SCAN_RETRIES) {
                    lock();
                    //获取到锁，则break退出循环
                    break;
                }
                //retries 为偶数的情况下 并且 查看当前线程获取锁过程中链表头结点是否发生了改变
                else  if ((retries & 1) == 0 &&
                         (f = entryForHash(this, hash)) != first) {
                    e = first = f; // re-traverse if entry changed
                    //如果发生了变化，重新设置为-1
                    retries = -1;
                }
            }
            return node;
        }

2.2.2 Segment#put#rehash

private void rehash(HashEntry<K,V> node) {
            HashEntry<K,V>[] oldTable = table;
            int oldCapacity = oldTable.length;
            //左移一位，成倍扩容
            int newCapacity = oldCapacity << 1;
            //重新计算阈值
            threshold = (int)(newCapacity * loadFactor);
            //创建一个新的table
            HashEntry<K,V>[] newTable =
                (HashEntry<K,V>[]) new HashEntry[newCapacity];
            //为了取余
            int sizeMask = newCapacity - 1;
            //遍历老数组
            for (int i = 0; i < oldCapacity ; i++) {
                HashEntry<K,V> e = oldTable[i];
                if (e != null) {
                	//定义next指向
                    HashEntry<K,V> next = e.next;
                    //算出新数组的下标
                    int idx = e.hash & sizeMask;
                    if (next == null)   //  Single node on list
                    	//如果next为null,说明只有一个元素，直接转移
                        newTable[idx] = e;
                    else { // Reuse consecutive sequence at same slot
                    	//如果next不等于null
                        HashEntry<K,V> lastRun = e;
                        int lastIdx = idx;
                        for (HashEntry<K,V> last = next;
                             last != null;
                             last = last.next) {
                            //遍历计算下标
                            int k = last.hash & sizeMask;
                            //如果和原来下标不一致，记录一下
                            if (k != lastIdx) {
                                lastIdx = k;
                                lastRun = last;
                            }
                        }
                        newTable[lastIdx] = lastRun;
                        // Clone remaining nodes
                        for (HashEntry<K,V> p = e; p != lastRun; p = p.next) {
                            V v = p.value;
                            int h = p.hash;
                            int k = h & sizeMask;
                            HashEntry<K,V> n = newTable[k];
                            newTable[k] = new HashEntry<K,V>(h, p.key, v, n);
                        }
                    }
                }
            }
            //对当前元素计算下标，上述是对已有元素转移
            int nodeIndex = node.hash & sizeMask; // add the new node
            //头插法设置
            node.setNext(newTable[nodeIndex]);
            newTable[nodeIndex] = node;
            table = newTable;
}

3. ConcurrentHashMap#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);
        long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
        //从segment数组中获取下标对应Segment对象
        //UNSAFE操作获取内存里最新的对象，而不是Cpu缓存里面的
        if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&
            (tab = s.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;
    }

三、总结

ConcurrentHashMap是Java中的一个线程安全的哈希表实现，它在多线程环境下提供了高效的并发访问。

1. 优点

它的优点包括：

• 1、线程安全：ConcurrentHashMap使用锁分段技术来实现线程安全，它将哈希表分成多个段，每个段拥有自己的锁，不同的线程可以同时访问不同的段，从而提高了并发性能。

• 2、高效性能：ConcurrentHashMap在并发环境下提供了较好的性能，读操作不需要加锁，写操作只需要锁定特定的段，而不是整个哈希表，从而减少了锁的竞争。

• 3、高效的迭代：ConcurrentHashMap的迭代器支持弱一致性，即在迭代期间，如果其他线程对哈希表进行修改，迭代器会继续返回旧的数据，而不会抛出ConcurrentModificationException异常。

• 4、增强的功能：ConcurrentHashMap提供了一些额外的功能，例如atomic putIfAbsent、replace和remove等方法，这些方法在并发环境下可以原子地执行操作。

2. 缺点

然而，ConcurrentHashMap也有一些缺点：

• 1、内存消耗较大：由于ConcurrentHashMap需要维护额外的线程安全机制，它的内存消耗比普通的HashMap要大。

• 2、有限的一致性：尽管ConcurrentHashMap提供了较好的并发性能，但它的一致性是弱一致性，即在并发修改的情况下，不能保证读取到最新的数据。

• 3、不支持空键和空值：ConcurrentHashMap不允许使用null作为键或值，如果需要使用null，可以使用特殊值来代替。

总体而言，ConcurrentHashMap是一个高效的线程安全哈希表实现，适用于并发访问的场景，但需要注意它的一些限制和特性。