2-2-3-9-1-2、jdk1.7ConcurrentHashMap详解

析道者

已于 2022-12-27 14:32:14 修改

阅读量549

点赞数

分类专栏：进阶并发编程-JDK 文章标签：数据结构 java 数组链表并发安全

于 2022-12-26 16:01:33 首次发布

本文链接：https://blog.csdn.net/weixin_41381248/article/details/128445570

版权

进阶同时被 2 个专栏收录

54 篇文章 0 订阅

订阅专栏

并发编程-JDK

20 篇文章 0 订阅

订阅专栏

数据结构

对比hashmap,hashmap数组对象类型是Entry对象类型，而ConcurrentHashMap数组对象类型是Segment[]数组，segment[]数组的对象类型为HashEntry类型(一个Segment里面包含一个HashEntry数组，每个HashEntry是一个链表结构，当对HashEntry数组的数据进行修改时，必须首先获得与它对应的Segment锁)

在这里插入图片描述

ConcurrentHashMap它采锁分段技术来保证高效的并发操作
ConcurrentHashMap把容器分为多个 segment（片段），每个片段有一把锁，当多线程访问容器里不同数据段的数据时，线程间就不会存在竞争关系；一个线程占用锁访问一个segment的数据时，并不影响另外的线程访问其他segment中的数据

源码分析

重要常量

// 默认初始容量
static final int DEFAULT_INITIAL_CAPACITY = 16;
// 默认加载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
// 默认segment层级
static final int DEFAULT_CONCURRENCY_LEVEL = 16;
// 最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;
// segment最小容量
static final int MIN_SEGMENT_TABLE_CAPACITY = 2;
// 一个segment最大容量
static final int MAX_SEGMENTS = 1 << 16;
// 锁之前重试次数
static final int RETRIES_BEFORE_LOCK = 2;

构造函数

public ConcurrentHashMap() {
    this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);
}
 
public ConcurrentHashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);
}
 
public ConcurrentHashMap(int initialCapacity, float loadFactor) {
    this(initialCapacity, loadFactor, DEFAULT_CONCURRENCY_LEVEL);
}

//无参构造器会用默认参数调用该构造器
//参数为默认的初始容量，加载因子，并发级别 initialCapacity==16，loadFactor==0.75f，concurrencyLevel==16
public ConcurrentHashMap(int initialCapacity,
                         float loadFactor, int concurrencyLevel) {
    //检查各参数是否符合要求
    if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)
        throw new IllegalArgumentException();
    //检查并发级别（即Segment数组的大小）是否超过最大值
    if (concurrencyLevel > MAX_SEGMENTS)
        concurrencyLevel = MAX_SEGMENTS;
    //扩容移位条件sshift
    int sshift = 0;
    //用于重新计算Segment数组的大小
    int ssize = 1;
    //将ssize调整为最小的2的n次幂且大于等于concurrencyLevel
    while (ssize < concurrencyLevel) {
        ++sshift;
        ssize <<= 1;
    }
    //根据sshift与ssize计算将来用于定位到相应Segment的参数segmentShift与segmentMask
    this.segmentShift = 32 - sshift;
    this.segmentMask = ssize - 1;
    //计算每个Segment内的数组HashEntry的大小
    if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;
    //c用来计算Segment内数组的大小 此处为向上取整操作
    int c = initialCapacity / ssize;
    if (c * ssize < initialCapacity)
        ++c;
    //cap为真正的Segment内的数组大小 需要调整为2的n次幂
    int cap = MIN_SEGMENT_TABLE_CAPACITY;
    while (cap < c)
        cap <<= 1;// 创建容量
    //创建0位置的Segment
    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[0]
    UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]
    this.segments = ss;
}

参数定义

DEFAULT_INITIAL_CAPACITY 初始容量默认值16
DEFAULT_LOAD_FACTOR 加载因子
DEFAULT_CONCURRENCY_LEVEL 并发级别默认值16

代码流程

首先对参数进行校验，然后通过while循环找到大于等于2的幂次方数作为ssize大小也就是segment数组长度，默认为16
通过int c = initialCapacity / ssize得到常量c，默认为1。然后判断c * ssize < initialCapacity如果是则ssize++。然后判断cap < c如果是则 cap <<= 1。保证cap是2的幂次方数
然后创建segment[0]位置不为null的segment数组。目的是为了进行segment.put操作时，需要重新计算segment对应hashEntry数组的大小，我们需要一个原型作为参考去掉多余计算步骤

put操作

首先校验value为不为空，为空则抛出空指针异常
调用hash()方法算出key的hashcode,ConcurrentHashMap的hash()方法与HashMap的方法是一样的
通过(hash >>> segmentShift) & segmentMask算出segment数组的索引位置。segmentMask在构造方法中（ this.segmentMask = ssize - 1）已经算好了，默认值为15。segmentShift 在构造方法中（this.segmentShift = 32 - sshift）已经算好了，值为28

Integer.numberOfLeadingZeros(ss)返回32位二进制数bit位为1之前的bit位数

System.out.println(Integer.numberOfLeadingZeros(1)); //0000 0000 0000 0000 0000 0000 0000 0001 31
System.out.println(Integer.numberOfLeadingZeros(16)); //0000 0000 0000 0000 0000 0000 0001 0000 27
System.out.println(Integer.numberOfLeadingZeros(32)); //0000 0000 0000 0000 0000 0000 0010 0000 26

UNSAFE.getObject(segments, (j << SSHIFT) + SBASE))这行代码的意思就是取segment数组第j个位置元素的对象。与上面UNSAFE的简单使用中案例一UNSAFE.getObject(person.table,base+1*ns)这行代码的意思是一样的
调用ensureSegment()生成segment对象并插入到segment【i】位置处。ensureSegment用于确定指定的Segment是否存在，不存在则会创建。注意这样只是乐观锁的一种写法并不能保证绝对的线程安全

public V put(K key, V value) {
    Segment<K,V> s;
    //value值不能为空
    if (value == null)
        throw new NullPointerException();
    int hash = hash(key);
    //将hash的高位移到低位 segmentMask在构造器中被初始为Segment数组长度减1
    //此处的与运算操作相当于对Segment数组的大小取余 求出hash值对应位置
    int j = (hash >>> segmentShift) & segmentMask;
    //判断要插入的Segment位置是否为空
    if ((s = (Segment<K,V>)UNSAFE.getObject
         (segments, (j << SSHIFT) + SBASE)) == null)
        //创建Segment
        s = ensureSegment(j);
    return s.put(key, hash, value, false);
}

创建Segment对象

private Segment<K,V> ensureSegment(int k) {
    final Segment<K,V>[] ss = this.segments;
    long u = (k << SSHIFT) + SBASE;
    Segment<K,V> seg;
    //防止多线程并发操作已经对当前位置创建了Segment
    if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u)) == null) {
        //从Segment[0]获取参数 HashEntry数组的大小和加载因子
        Segment<K,V> proto = ss[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];
        //再次确认是否有其它线程已经创建了Segment
        if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))
            == null) {
            //创建Segment
            Segment<K,V> s = new Segment<K,V>(lf, threshold, tab);
            //再次确认是否有其它线程已经创建了Segment
            //使用while的原因是若在CAS操作时失败，即已经有其它线程创建了Segment，可以在循环体判断中获取到被其它线程创建的Segment
            while ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))
                   == null) {
                //CAS为原子操作即两个线程执行一定会有先后顺序 若u位置为null将seg赋给ss的u位置
                if (UNSAFE.compareAndSwapObject(ss, u, null, seg = s))
                    break;
            }
        }
    }
    return seg;
}

调用Segment对象的put方法

首先遍历该链表，如果在该链中找到相同的key，则用新值替换旧值，并退出循环，如果没有和key相同的，一直遍历到链尾，链尾的next为null，如果node不为空则调用 node.setNext(first)方法，把当前的Entry插入到表头。否则创建一个Entry插入到表头

final V put(K key, int hash, V value, boolean onlyIfAbsent) {
	//tryLock 尝试获取锁，即使获取失败，后面的代码也会继续执行
	//Lock 获取锁，若获取失败，则进入阻塞状态
	//此时若尝试获取锁失败，则会引入自旋锁
	HashEntry<K,V> node = tryLock() ? null :
		scanAndLockForPut(key, hash, value);
	V oldValue;
	//下面为链表的插入操作
	try {
		//tab是当前segment所连接的HashEntry数组
		HashEntry<K,V>[] tab = table;
		//确定key的hash值所在HashEntry数组的索引位置
		int index = (tab.length - 1) & hash;
		//取得要放入的HashEntry链的链头
		HashEntry<K,V> first = entryAt(tab, index);
		//遍历当前HashEntry链
		for (HashEntry<K,V> e = first;;) {
			//如果链头不为null
			if (e != null) {
				K k;
				//如果在该链中找到相同的key，则用新值替换旧值，并退出循环
				if ((k = e.key) == key ||
					(e.hash == hash && key.equals(k))) {
					oldValue = e.value;
					if (!onlyIfAbsent) {
						e.value = value;
						++modCount;
					}
					break;
				}
				//如果没有和key相同的，一直遍历到链尾，链尾的next为null，进入到else
				e = e.next;
			}
			else {
				//如果没有找到key相同的，则把当前Entry插入到链头
				if (node != null)
					node.setNext(first);
				else
					node = new HashEntry<K,V>(hash, key, value, first);
				//此时数量+1
				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;
}

获取锁失败，自旋获取锁

调用segment对象的put方法的时候会调用tryLock()尝试去加锁【trylock如果获取不到锁会立即返回false,lock获取锁的时候，如果获取不到就会阻塞，一直等到获取锁成功】。如果tryLock加锁成功则node为空，如果trylock失败则调用scanAndLockForPut()方法scanAndLockForPut()方法的目的是在线程等待的时间内做一些准备工作，创建HashEntry对象
scanAndLockForPut()方法的工作过程：
首先是循环的尝试获取锁，通过循环去遍历链表。循环的时候有三个分支

先判断retries是否为-1，如果为是则判断HashEntry是否为空，如果为空则创建HashEntry对象，如果不为空就判断该链的节点是否相同。如果都不是则进入下一节点
retries ++并判断retries是否达到最大值，如果是则调用Lock()方法一直等待到获取锁成功
在循环中有一个重试机制，每一次循环retries 都会加一，当retries 为偶数的时候，会重试判断当前链的头是不是发生改变，如果发生改变则重新遍历该链表。最后返回node

private HashEntry<K,V> scanAndLockForPut(K key, int hash, V value) {
    //获取要插入的Segment的第一个节点
    HashEntry<K,V> first = entryForHash(this, hash);
    HashEntry<K,V> e = first;
    HashEntry<K,V> node = null;
    //while循环为一直尝试获取锁 使用tryLock可以在未获取锁的时候进行一些其它操作提高效率
    //retries变量起到引导作用 判断当前应该进行什么操作
    int retries = -1;
    while (!tryLock()) {
        HashEntry<K,V> f;
        //若retries小于0 则进行遍历链表操作
        //若遍历到表尾则创建HashEntry或者找到key相同的HashEntry 将retries置为0
        if (retries < 0) {
            if (e == null) {
                if (node == null) // speculatively create node
                    node = new HashEntry<K,V>(hash, key, value, null);
                retries = 0;
            }
            else if (key.equals(e.key))
                retries = 0;
            else
                e = e.next;
        }
        //此时为遍历链表的操作已经结束还未获取到锁 不能一直处于循环状态占用CPU内存
        //每进行一次循环会让retries变量+1 当retries大于64时 调用Lock方法
        else if (++retries > MAX_SCAN_RETRIES) {
            lock();
            break;
        }
        //判断在循环等待的过程中 链表结构是否发生了变化即头结点发生改变 若改变则将retries置为-1 重新进行遍历链表操作
        //为了避免在判断头结点是否改变的过程中 释放的锁被其它线程抢走 只在retries为奇数时判断
        else if ((retries & 1) == 0 &&
                 (f = entryForHash(this, hash)) != first) {
            e = first = f; // re-traverse if entry changed
            retries = -1;
        }
    }
    return node;
}

扩容操作

ConcurrentHashMap不存在在高并发场景下HashMap在扩容中存在的循环链表的问题，因为ConcurrentHashMap在put时已经加锁
ConcurrentHashMap的rehash方法和Hashmap中的resize方法基本是一样的，都是先扩容两倍，再通过((newTableLentgh-1) & key.hash)求出节点在新table中的位置，接着用头插法把原table中的节点插入到新table中。不过Segment的rehash方法加入了一点优化判断，就是在遍历原table的时候，会用lastRun和lastIdx来记录每个单链表上的一个节点，如果这个节点及后面的节点在新table中的映射位置相同，这样在插入的时候直接插入lastRun即可，后面的元素也就跟着一起插入了。也就是记录当前循环次数中连续的节点的头节点，如果后面的循环同样出现连续的节点，那么则覆盖前面已经记录的头节点，永远记录最新的头节点

private void rehash(HashEntry<K,V> node) {
    HashEntry<K,V>[] oldTable = table;
    int oldCapacity = oldTable.length;
    int newCapacity = oldCapacity << 1;
    threshold = (int)(newCapacity * loadFactor);
    HashEntry<K,V>[] newTable =
        (HashEntry<K,V>[]) new HashEntry[newCapacity];
    int sizeMask = newCapacity - 1;
    // 遍历segemnt链表
    for (int i = 0; i < oldCapacity ; i++) {
        HashEntry<K,V> e = oldTable[i];
        if (e != null) {
            HashEntry<K,V> next = e.next;
            int idx = e.hash & sizeMask;
            if (next == null)   //  单节点链表
                newTable[idx] = e;
            else { 
                //该位置存在多节点链表
                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;
                // 克隆剩余节点
                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);
                }
            }
        }
    }
    //添加最新的node节点到新数组中
    int nodeIndex = node.hash & sizeMask; // add the new node
    node.setNext(newTable[nodeIndex]);
    newTable[nodeIndex] = node;
    table = newTable;
}

get操作

get方法是没有加锁解锁动作的，但是也能实现并发同步的效果。原因是因为通过UNSAFE进行查询得到内存中的数据，对于其他线程来说是可见的

public V get(Object key) {
    Segment<K,V> s; // manually integrate access methods to reduce overhead
    HashEntry<K,V>[] tab;
    int h = hash(key);
    //要查找的key属于segment[u]
    long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
    //segment[u] != null且segment[u]中的table[] != null
    if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&
        (tab = s.table) != null) {
        //找到key映射位置上的链表并遍历
        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;
            //查找成功就返回val
            if ((k = e.key) == key || (e.hash == h && key.equals(k)))
                return e.value;
        }
    }
    //查找失败返回null
    return null;
}

remove操作

remove操作首先尝试获取锁，获取到了锁后进行table的遍历，查找到指定key位置的节点后删除该节点，并返回原节点的值。节点删除过程同Hashmap

 final V remove(Object key, int hash, Object value) {
    if (!tryLock())
        scanAndLock(key, hash);
    V oldValue = null;
    try {
        HashEntry<K,V>[] tab = table;
        int index = (tab.length - 1) & hash;
        HashEntry<K,V> e = entryAt(tab, index);
        HashEntry<K,V> pred = null;
        while (e != null) {
            K k;
            HashEntry<K,V> next = e.next;
            if ((k = e.key) == key ||
                (e.hash == hash && key.equals(k))) {
                V v = e.value;
                if (value == null || value == v || value.equals(v)) {
                    if (pred == null)
                        setEntryAt(tab, index, next);
                    else
                        pred.setNext(next);
                    ++modCount;
                    --count;
                    oldValue = v;
                }
                break;
            }
            pred = e;
            e = next;
        }
    } finally {
        unlock();
    }
    return oldValue;
}