猿码研读之ConcurrentHashMap1.7

ConcurrentHashMap1.7

• • ConcurrentHashMap成员变量
  • ConcurrentHashMap构造方法
  • • Segment构造方法
  • Put方法
  • • ensureSegment方法
    • Segment下的Put方法
    • • scanAndLockForPut方法
  • Get方法
  • 小结

通过前面学习HashMap1.7和HashMap1.8的工作原理之后可以发现HashMap存在缺点：线程不安全，可能有些猿友们会想到，那肯定是没有加锁控制才会出现线程不安全的问题，那么优化方案就是给操作HashMap的Put和GET等方法时候统一添加JDK自带的synchronized锁，而HashTable就是这么处理的。如今处于高速发展的互联网时代，并发执行效率是关注的首要话题，俗话说：技术点的更新迭代都是因为需求产生的，故此引出ConcurrentHashMap，而它确实解决了并发效率执行的问题，所以也就出现此篇猿文吧！

ConcurrentHashMap成员变量

public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>implements ConcurrentMap<K, V>, Serializable {/* ---------------- Constants -------------- */// 默认初始化容量为16 (在构造方法中未引用)static final int DEFAULT_INITIAL_CAPACITY = 16;// 默认加载因子0.75 (在构造方法中未引用)static final float DEFAULT_LOAD_FACTOR = 0.75f;// 默认并发等级16static final int DEFAULT_CONCURRENCY_LEVEL = 16;// 默认最大容量为2^30static final int MAXIMUM_CAPACITY = 1 << 30;// 每个segment中的最小数组容量static final int MIN_SEGMENT_TABLE_CAPACITY = 2;// segment数组的最大值为2^16static final int MAX_SEGMENTS = 1 << 16;/*** Number of unsynchronized retries in size and containsValue* methods before resorting to locking. This is used to avoid* unbounded retries if tables undergo continuous modification* which would make it impossible to obtain an accurate result.*/static final int RETRIES_BEFORE_LOCK = 2;// 用于计算segments下标值final int segmentMask;// 用于计算segments下标值final int segmentShift;// segments数组final Segment<K,V>[] segments;

ConcurrentHashMap构造方法

/*** 解读构造方法参数* @param initialCapacity:自定义初始化容量值 默认16* @param loadFactor : 自定义加载因子 默认0.75f* @param concurrencyLevel: 并发等级，可以理解为同一时间段可以有concurrencyLevel个线程同时执行，若大于则需要等待锁资源，默认16*/
public ConcurrentHashMap(int initialCapacity,float loadFactor, int concurrencyLevel) {// 校验参数（loadFactor || initialCapacity || concurrencyLevel  ）必须大于0if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)throw new IllegalArgumentException();// 并发等级最大值为2^16if (concurrencyLevel > MAX_SEGMENTS)concurrencyLevel = MAX_SEGMENTS;int sshift = 0;// segments数组的偏移量int ssize = 1;// segments数组的默认大小while (ssize < concurrencyLevel) {// 若concurrencyLevel为默认值16，则ssize =16 sshift=4 break循环++sshift;ssize <<= 1;}this.segmentShift = 32 - sshift;// 28this.segmentMask = ssize - 1;//15// 判断初始化容量值是否大于最大值if (initialCapacity > MAXIMUM_CAPACITY)initialCapacity = MAXIMUM_CAPACITY;int c = initialCapacity / ssize;//  c= 16/16=1if (c * ssize < initialCapacity)++c;int cap = MIN_SEGMENT_TABLE_CAPACITY;//每个segment下的table最小容量大小=2while (cap < c)cap <<= 1;// 创建segments[0]，而S0下的table数组大小为2，等后面需要时再进行创建Segment<K,V> s0 =new Segment<K,V>(loadFactor, (int)(cap * loadFactor),(HashEntry<K,V>[])new HashEntry[cap]);// 创建segments 数组 ，容量大小为ssize=16，具体的大小由ssize决定Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize];// 通过Unsafe将S0存入segments 数组中// TODO 此处需要了解下Unsafe（并发操作类）UNSAFE.putOrderedObject(ss, SBASE, s0);// 将数组ss指向segments this.segments = ss;}

Segment构造方法

/*** 根据类关系可以发现单个Segment类继承自ReentrantLock ，而ReentrantLock 是juc下支持并发编程操作的一个类* 同时可以发现，每个Segment都包含了自己的table数组，且Segment仅控制自己的table数组，而Segments数组锁与锁之前分开互不影响，也被称为分段锁。*/
static final class Segment<K,V> extends ReentrantLock implements Serializable {// 自旋锁的最大次数static final int MAX_SCAN_RETRIES =Runtime.getRuntime().availableProcessors() > 1 ? 64 : 1;		// Segment下的table数组 且被volatile关键字修饰 transient volatile HashEntry<K,V>[] table;// 用于统计元素的个数 类似于HashMap的size方法transient int count;// 操作当前segment的次数transient int modCount;// table待扩容阈值(int)(capacity * loadFactor).)transient int threshold;// 加载因子 默认和segments保持一致final float loadFactor;// 构造方法Segment(float lf, int threshold, HashEntry<K,V>[] tab) {this.loadFactor = lf;this.threshold = threshold;this.table = tab;}// TODO 继续阅读代码可以发现 Segment 重写了Put和get等方法。
....
}

Put方法

    public V put(K key, V value) {// 定义一个segmentSegment<K,V> s;// 不允许value 为空if (value == null)throw new NullPointerException();// 根据key获取hashcode值int hash = hash(key);// 获取segments数组的下标index=(hash >>> segmentShift) & segmentMaskint j = (hash >>> segmentShift) & segmentMask;//当前segment为空，需要创建一个segment,进入ensureSegment方法if ((s = (Segment<K,V>)UNSAFE.getObject(segments, (j << SSHIFT) + SBASE)) == null)s = ensureSegment(j);// 调用segment的put方法return s.put(key, hash, value, false);}

ensureSegment方法

/*** 获取一个Segment对象，由于此处没有加锁控制，因此多次通过Segment)UNSAFE.getObjectVolatile(ss, u)) == null进行判断，来保证segments数组中下标index仅创建唯一一个Segment*/
private Segment<K,V> ensureSegment(int k) {// segments数组指向ssfinal Segment<K,V>[] ss = this.segments;// 计算偏移量值 ulong u = (k << SSHIFT) + SBASE;Segment<K,V> seg;if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u)) == null) {	// 为空表示下标index的Segment对象仍为空// 取ss[0]的相关配置信息，即就是后面创建的Segment配置均以ss[0]为准则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];//创建一个新数组if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))== null) { // recheck ,为空表示下标index的Segment对象仍为空// 创建一个SegmentSegment<K,V> s = new Segment<K,V>(lf, threshold, tab);			// 采用自旋的方式 再次对segment判断是否为空while ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))== null) {// 使用unsafe的CSA完成ss数组的元素添加 确保独一份 ，随后break终止while循环if (UNSAFE.compareAndSwapObject(ss, u, null, seg = s))break;}}}// 返回segment对象 （可能由任意一个线程产生，返回即可）return seg;}

Segment下的Put方法

/*** lock():如果锁被另一个线程持有，那么当前线程出于线程调度的目的将被禁用，并处于休眠状态，直到获得锁，此时锁持有计数被设置为1。* tryLock():如果当前线程已经持有该锁，则保持计数加1，方法返回true。
如果锁被另一个线程持有，则此方法将立即返回值为false* 以上二者区别：tryLock可以尝试获取锁，而不会让其他线程处于休眠状态，即就是在获取不到锁的情况下可以试着做些其他事情scanAndLockForPut()方法。*/
final V put(K key, int hash, V value, boolean onlyIfAbsent) {// 使用tryLock方法获取锁HashEntry<K,V> node = tryLock() ? null :scanAndLockForPut(key, hash, value);V oldValue;try {/*** 表示获取到lock锁 逻辑与HashMap的Put方法逻辑一致，如以下三步:* 1、获取下标index* 2、获取下标index位置对应的头结点HashEntry* 3、循环遍历链表元素(元素是否存在-> 不存在添加新节点HashEntry，若存在则返回oldValue，再就是数组扩容等逻辑)*/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);elsenode = new HashEntry<K,V>(hash, key, value, first);int c = count + 1;if (c > threshold && tab.length < MAXIMUM_CAPACITY)rehash(node);elsesetEntryAt(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) {	// 获取头结点firstHashEntry<K,V> first = entryForHash(this, hash);HashEntry<K,V> e = first;HashEntry<K,V> node = null;int retries = -1; // 统计线程自旋的次数// 以下是采用自旋的方式来获取lock锁while (!tryLock()) {HashEntry<K,V> f; // to recheck first belowif (retries < 0) {if (e == null) {if (node == null) // speculatively create nodenode = new HashEntry<K,V>(hash, key, value, null);retries = 0;}else if (key.equals(e.key))retries = 0;elsee = e.next;}else if (++retries > MAX_SCAN_RETRIES) {// retries最多尝试64次 之后该线程会再次获取lock锁，如果再获取不到，则会处于阻塞中(即就是线程阻塞中), 随后break 退出循环lock();break;}else if ((retries & 1) == 0 &&(f = entryForHash(this, hash)) != first) {					// 因为jdk1.7在插入的时候采用的是头插法，故此处比较头结点是否跟first是否一致，如果不相等，则表示链表被调整了e = first = f; //将节点e和first赋值为最新头节点fretries = -1;// retries 置为-1 重新自旋}}// 返回node节点return node;}

Get方法

public V get(Object key) {Segment<K,V> s; // segment对象HashEntry<K,V>[] tab;int h = hash(key);//获取hashcode// 根据hashcode、segment偏移量以及segment掩码来获取segments数组下标long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;// 如果数组不为空且segment也不为空，且segment的table数组也不为空，则说明元素存在，需要进行遍历segment的table数组下的链表元素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;// 如果key相等或(hashcode相等且key也相等)时,返回value值if ((k = e.key) == key || (e.hash == h && key.equals(k)))return e.value;}}// 返回nullreturn null;}

小结

如上分析可以得到，ConcurrentHashMap是不允许value值为空的，但是key是可以为空，区别于HashMap是Key和value均可以为空，数据存储结构仍为数组+链表的形式，那么ConcurrentHashMap是如何避免线程安全问题呢？如下分析：

• 1、采用分段锁的思想进行分段控制（Segments），Segment继承自ReentrantLock，并且在Segment内部 重写了put和get方法，不过大概逻辑是在添加元素时增加了lock和unlock。
• 2、Segment包含了自身的table属性，多个Segment之间操作互不影响。

以上就是我对ConcurrentHashMap和HashMap区别的理解，不过吸引我的是jdk1.8对于ConcurrentHashMap的调整，因为毕竟数据结构发生了改变，引入了红黑树，我的好奇心是对于数组扩容和数据转移方面jdk1.8又会是怎么处理的呢，那么下一篇文章就以此为引吧!!! 下次见哦。

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！