ConcurrentHashMap 总结

最新推荐文章于 2024-08-15 13:58:36 发布

TooStrongerW

最新推荐文章于 2024-08-15 13:58:36 发布

阅读量2.1k

点赞数 3

分类专栏： java

本文链接：https://blog.csdn.net/wsxsmmx/article/details/105221210

版权

java 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

ConcurrentHashMap

介绍

Hashmap多线程会导致HashMap的Entry链表形成环形数据结构，一旦形成环形数据结构，Entry的next节点永远不为空，就会产生死循环获取Entry。

HashTable使用synchronized来保证线程安全，但在线程竞争激烈的情况下HashTable的效率非常低下。因为当一个线程访问HashTable的同步方法，其他线程也访问HashTable的同步方法时，会进入阻塞或轮询状态。如线程1使用put进行元素添加，线程2不但不能使用put方法添加元素，也不能使用get方法来获取元素，所以竞争越激烈效率越低。

putIfAbsent() ：没有这个值则放入map，有这个值则返回key本来对应的值。

Hash

散列，哈希：把任意长度的输入通过一种算法（散列），变换成为固定长度的输出，这个输出值就是散列值。属于压缩映射，容易产生哈希冲突。Hash算法有直接取余法等。

产生哈希冲突时解决办法：1.开放寻址；2、再散列；3、链地址法（相同hash值的元素用链表串起来）。

ConcurrentHashMap在发生hash冲突时采用了链地址法。

md4,md5,sha-hash算法也属于hash算法，又称摘要算法。

1.7中原理和实现

ConcurrentHashMap中的数据结构

ConcurrentHashMap是由Segment数组结构和HashEntry数组结构组成。Segment实际继承自可重入锁（ReentrantLock），在ConcurrentHashMap里扮演锁的角色；HashEntry则用于存储键值对数据。一个ConcurrentHashMap里包含一个Segment数组，每个Segment里包含一个HashEntry数组，我们称之为table，每个HashEntry是一个链表结构的元素。

ConcurrentHashMap实现原理是怎么样的或者问ConcurrentHashMap如何在保证高并发下线程安全的同时实现了性能提升？

ConcurrentHashMap允许多个修改操作并发进行，其关键在于使用了锁分离技术。它使用了多个锁来控制对hash表的不同部分进行的修改。内部使用段(Segment)来表示这些不同的部分，每个段其实就是一个小的hash table，只要多个修改操作发生在不同的段上，它们就可以并发进行

初始化做了什么事？

初始化有三个参数

initialCapacity：初始容量大小，默认16。

loadFactor, 扩容因子，默认0.75，当一个Segment存储的元素数量大于initialCapacity* loadFactor时，该Segment会进行一次扩容。

concurrencyLevel 并发度，默认16。并发度可以理解为程序运行时能够同时更新ConccurentHashMap且不产生锁竞争的最大线程数，实际上就是ConcurrentHashMap中的分段锁个数，即Segment[]的数组长度。如果并发度设置的过小，会带来严重的锁竞争问题；如果并发度设置的过大，原本位于同一个Segment内的访问会扩散到不同的Segment中，CPU cache命中率会下降，从而引起程序性能下降。

源码部分

保证Segment数组的大小，一定为2的幂，例如用户设置并发度为17，则实际Segment数组大小则为32

保证每个Segment中tabel数组的大小，一定为2的幂，初始化的三个参数取默认值时，table数组大小为2

初始化Segment数组，并实际只填充Segment数组的第0个元素。

用于定位元素所在segment。segmentShift表示偏移位数，通过前面的int类型的位的描述我们可以得知，int类型的数字在变大的过程中，低位总是比高位先填满的，为保证元素在segment级别分布的尽量均匀，计算元素所在segment时，总是取hash值的高位进行计算。segmentMask作用就是为了利用位运算中取模的操作：l a % (Math.pow(2,n)) 等价于 a&( Math.pow(2,n)-1)

在get和put操作中，是如何快速定位元素放在哪个位置的？

对于某个元素而言，一定是放在某个segment元素的某个table元素中的，所以在定位上，

定位segment：取得key的hashcode值进行一次再散列（通过Wang/Jenkins算法），拿到再散列值后，以再散列值的高位进行取模得到当前元素在哪个segment上。

定位table：同样是取得key的再散列值以后，用再散列值的全部和table的长度进行取模，得到当前元素在table的哪个元素上。

get（）方法

定位segment和定位table后，依次扫描这个table元素下的的链表，要么找到元素，要么返回null。

在高并发下的情况下如何保证取得的元素是最新的？

答：用于存储键值对数据的HashEntry，在设计上它的成员变量value等都是volatile类型的，这样就保证别的线程对value值的修改，get方法可以马上看到。

put()方法

1、首先定位segment，当这个segment在map初始化后，还为null，由ensureSegment方法负责填充这个segment。

2、对Segment 加锁

3、定位所在的table元素，并扫描table下的链表，找到时：

没有找到时：

扩容操作

Segment 不扩容，扩容下面的table数组，每次都是将数组翻倍

size方法

size的时候进行两次不加锁的统计，两次一致直接返回结果，不一致，重新加锁再次统计

弱一致性

get方法和containsKey方法都是通过对链表遍历判断是否存在key相同的节点以及获得该节点的value。但由于遍历过程中其他线程可能对链表结构做了调整，因此get和containsKey返回的可能是过时的数据，这一点是ConcurrentHashMap在弱一致性上的体现。

1.8

与1.7相比的重大变化

取消了segment数组，直接用table保存数据，锁的粒度更小，减少并发冲突的概率。
存储数据时采用了链表+红黑树的形式，纯链表的形式时间复杂度为O(n)，红黑树则为O（logn），性能提升很大。什么时候链表转红黑树？当key值相等的元素形成的链表中元素个数超过8个的时候。

主要数据结构和关键变量

Node类存放实际的key和value值。

sizeCtl：

负数：表示进行初始化或者扩容,-1表示正在初始化，-N，表示有N-1个线程正在进行扩容

正数：0 表示还没有被初始化，>0的数，初始化或者是下一次进行扩容的阈值

TreeNode 用在红黑树，表示树的节点, TreeBin是实际放在table数组中的，代表了这个红黑树的根。

初始化做了什么事？

只是给成员变量赋值，put时进行实际数组的填充

在get和put操作中，是如何快速定位元素放在哪个位置的？

get（）方法

put()方法

数组的实际初始化

扩容操作

transfer()方法进行实际的扩容操作，table大小也是翻倍的形式，有一个并发扩容的机制。

size方法

估计的大概数量，不是精确数量

----------------------------------------------------------------------2020-11-20----------------------------------------------------------------------------------

compute方法：

多个线程对ConcurrentHashMap get/put操作实际上也不是线程安全

可以用compute方法来进行操作，例：

/**
 * <pre>
 * classname Test
 * description
 * </pre>
 *
 * @author wangp
 * @date 2020/11/20 10:07
 **/
public class ConcurrentHashMapDemo implements Runnable {

    static ConcurrentHashMap<String, Integer> concurrentHashMap = new ConcurrentHashMap<>();

    public static void main(String[] args) throws InterruptedException {
        concurrentHashMap.put("key", 0);
        Thread t1 = new Thread(new ConcurrentHashMapDemo());
        Thread t2 = new Thread(new ConcurrentHashMapDemo());
        t1.start();
        t2.start();
        t1.join();
        t2.join();

        System.out.println(concurrentHashMap.get("key"));
    }

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            Integer value = concurrentHashMap.get("key");
            concurrentHashMap.put("key", ++value);
        }
    }
}

输出：

第一次：1166

第二次：1213

可见不是线程安全的。

用Compute,例：

/**
 * <pre>
 * classname Test
 * description
 * </pre>
 *
 * @author wangp
 * @date 2020/11/20 10:07
 **/
public class ConcurrentHashMapDemo implements Runnable {

    static ConcurrentHashMap<String, Integer> concurrentHashMap = new ConcurrentHashMap<>();

    public static void main(String[] args) throws InterruptedException {
        concurrentHashMap.put("key", 0);
        Thread t1 = new Thread(new ConcurrentHashMapDemo());
        Thread t2 = new Thread(new ConcurrentHashMapDemo());
        t1.start();
        t2.start();
        t1.join();
        t2.join();

        System.out.println(concurrentHashMap.get("key"));
    }

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            concurrentHashMap.compute("key", (k, v) -> ++v);
        }
    }
}

一直输出：2000