Java常见集合框架(二十一)： Map之ConcurrentMap、ConcurrentHashMap

最新推荐文章于 2024-09-03 17:01:47 发布
最新推荐文章于 2024-09-03 17:01:47 发布
阅读量669 收藏 1
点赞数
分类专栏： Java Java常见集合框架 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a355586533/article/details/78332648
版权

##ConcurrentMap

public interface ConcurrentMap extends Map

  1. 提供其他原子 putIfAbsent、remove、replace 方法的 Map。
  2. 内存一致性效果：当存在其他并发 collection 时，将对象放入 ConcurrentMap 之前的线程中的操作 happen-before 随后通过另一线程从 ConcurrentMap 中访问或移除该元素的操作。

接口方法

    /**
     *  如果指定键已经不再与某个值相关联，则将它与给定值关联。
     */
    V putIfAbsent(K key, V value);

    /**
     *  只有目前将键的条目映射到给定值时，才移除该键的条目。
     */
    boolean remove(Object key, Object value);

    /**
     *  只有目前将键的条目映射到某一值时，才替换该键的条目。
     */
    boolean replace(K key, V oldValue, V newValue);

    /**
     *  只有目前将键的条目映射到给定值时，才替换该键的条目。
     */
    V replace(K key, V value);

##ConcurrentHashMap

public class ConcurrentHashMap extends AbstractMap implements ConcurrentMap, Serializable

  1. 支持获取的完全并发和更新的所期望可调整并发的哈希表。
  2. 不允许将 null 用作键或值。
  3. 适用于读多写少场景。

成员变量

 /* ---------------- Constants -------------- */

    /**
     * 默认初始容量
     */
    static final int DEFAULT_INITIAL_CAPACITY = 16;

    /**
     * 默认装载因子
     */
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    /**
     * 默认更新并发线程数
     */
    static final int DEFAULT_CONCURRENCY_LEVEL = 16;

    /**
     * 最大容量
     */
    static final int MAXIMUM_CAPACITY = 1 << 30;

    /**
     * SEGMENT最大个数
     */
    static final int MAX_SEGMENTS = 1 << 16; // slightly conservative

    /**
     * 锁之前重试次数
     */
    static final int RETRIES_BEFORE_LOCK = 2;

    /* ---------------- Fields -------------- */

    /**
     * 段标记
     */
    final int segmentMask;

    /**
     * 段的偏移量
     */
    final int segmentShift;

    /**
     * 特殊table-段
     */
    final Segment<K,V>[] segments;

    transient Set<K> keySet;
    transient Set<Map.Entry<K,V>> entrySet;
    transient Collection<V> values;

    /* ---------------- Small Utilities -------------- */

构造方法

//创建一个带有默认初始容量 (16)、加载因子 (0.75) 和 concurrencyLevel (16) 的新的空映射。
ConcurrentHashMap() 

// 创建一个带有指定初始容量、默认加载因子 (0.75) 和 concurrencyLevel (16) 的新的空映射。          
ConcurrentHashMap(int initialCapacity) 

// 创建一个带有指定初始容量、加载因子和默认 concurrencyLevel (16) 的新的空映射。         
ConcurrentHashMap(int initialCapacity, float loadFactor) 

//创建一个带有指定初始容量、加载因子和并发级别的新的空映射。
ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel) 

//构造一个与给定映射具有相同映射关系的新映射。 
ConcurrentHashMap(Map<? extends K,? extends V> m)

常用核心方法

V put(K key, V value) ：将指定键映射到此表中的指定值。键和值都不可以为 null。返回以前与 key 相关联的值，如果 key 没有映射关系，则返回 null。

    public V put(K key, V value) {
        if (value == null)
            throw new NullPointerException();//非空校验
        int hash = hash(key.hashCode());//再哈希
        return segmentFor(hash).put(key, hash, value, false);
    }

V putIfAbsent(K key, V value)：如果指定键已经不再与某个值相关联，则将它与给定值关联。返回以前与指定键相关联的值，如果该键没有映射关系，则返回 null。

    public V putIfAbsent(K key, V value) {
        if (value == null)
            throw new NullPointerException();
        int hash = hash(key.hashCode());
        return segmentFor(hash).put(key, hash, value, true);
    }

final Segment segmentFor(int hash)：根据哈希码计算对应的段segment。

    final Segment<K,V> segmentFor(int hash) {
        return segments[(hash >>> segmentShift) & segmentMask];
    }

V put(K key, int hash, V value, boolean onlyIfAbsent)：Segment内部类方法。

static final class Segment<K,V> extends ReentrantLock implements Serializable {
	
	V put(K key, int hash, V value, boolean onlyIfAbsent) {
            lock();//调用父类获取锁方法
            try {
                int c = count;
                if (c++ > threshold) // 判断是否需要扩容
                    rehash();
                HashEntry<K,V>[] tab = table;
                int index = hash & (tab.length - 1);//计算索引
                HashEntry<K,V> first = tab[index];//获取到对应的链表
                HashEntry<K,V> e = first;
                //遍历链表，获取到对应元素
                while (e != null && (e.hash != hash || !key.equals(e.key)))
                    e = e.next;

                V oldValue;
                if (e != null) {//已存在对应key-value
                    oldValue = e.value;
                    if (!onlyIfAbsent)//判断是否更新value
                        e.value = value;
                }
                else {//key首次put
                    oldValue = null;
                    ++modCount;//修改次数+1
                    tab[index] = new HashEntry<K,V>(key, hash, first, value);
                    count = c; // write-volatile
                }
                return oldValue;
            } finally {
                unlock();//释放锁
            }
        }
}

V remove(Object key)：从此映射中移除键（及其相应的值）。

    public V remove(Object key) {
		int hash = hash(key.hashCode());
        return segmentFor(hash).remove(key, hash, null);
    }

boolean remove(Object key, Object value)：只有目前将键的条目映射到给定值时，才移除该键的条目。

    public boolean remove(Object key, Object value) {
        int hash = hash(key.hashCode());
        if (value == null)
            return false;
        return segmentFor(hash).remove(key, hash, value) != null;
    }

V remove(Object key, int hash, Object value)：Segment内部类方法。

static final class Segment<K,V> extends ReentrantLock implements Serializable {
	
	 V remove(Object key, int hash, Object value) {
            lock();//获取锁
            try {
                int c = count - 1;
                HashEntry<K,V>[] tab = table;
                int index = hash & (tab.length - 1);
                HashEntry<K,V> first = tab[index];
                HashEntry<K,V> e = first;
                //找对应key-value
                while (e != null && (e.hash != hash || !key.equals(e.key)))
                    e = e.next;

                V oldValue = null;
                if (e != null) {//有对应key-value
                    V v = e.value;
                    if (value == null || value.equals(v)) {
                        oldValue = v;
                        ++modCount;//修改次数+1
                        HashEntry<K,V> newFirst = e.next;
                        //next由final修饰不可变，故移除的节点前所有元素均需要clone。
            for (HashEntry<K,V> p = first; p != e; p = p.next)
newFirst = new HashEntry<K,V>(p.key, p.hash, newFirst, p.value);//                                                 
                        tab[index] = newFirst;
                        count = c; // write-volatile
                    }
                }
                return oldValue;
            } finally {
                unlock();
            }
        }
}

内部类HashEntry
由于key、value、及next均由final声明，故执行remvoe操作后，移除元素的前一个元素对应entry.next值应该变了，但由于final定义，导致不能再改变它，故将它之前的节点全都克隆一次。

 static final class HashEntry<K,V> {
        final K key;
        final int hash;
        volatile V value;
        final HashEntry<K,V> next;
}

V get(Object key)：返回指定键所映射到的值，如果此映射不包含该键的映射关系，则返回 null。

    public V get(Object key) {
        int hash = hash(key.hashCode());
        return segmentFor(hash).get(key, hash);
    }

V get(Object key, int hash) ：Segment内部方法。

        V get(Object key, int hash) {
            if (count != 0) { // read-volatile 有key-value
                HashEntry<K,V> e = getFirst(hash);//找到对应的链表，并返回头节点
                //遍历链表,找到对应键值对
                while (e != null) {
                    if (e.hash == hash && key.equals(e.key)) {
                        V v = e.value;
                        if (v != null)
                            return v;
                        return readValueUnderLock(e); // recheck
                    }
                    e = e.next;
                }
            }
            return null;
        }
        
        HashEntry<K,V> getFirst(int hash) {
            HashEntry<K,V>[] tab = table;
            return tab[hash & (tab.length - 1)];
        }

总结：

  1. ConcurrentHashMap采用分段锁设计(Segment)，默认初始将Map分为16段即Segment[] segments数组长度16，也可理解为写线程并发度为16。
  2. Segment extends ReentrantLock则每个分段Segment都拥有自己的ReentrantLock，减少锁竞争。
  3. 如果并发度设置的过小，会带来严重的锁竞争问题；如果并发度设置的过大，原本位于同一个Segment内的访问会扩散到不同的Segment中，CPU cache命中率会下降，从而引起程序性能下降。
  4. Segment中成员变量：transient volatile int count;表示对应Segment中key-value元素个数，当count==0时，get操作直接返回，避免不必要的査找开销。
  5. Segment中有个重要成员变量：volatile transient ConcurrentHashMap.HashEntry[] table。每个Segment中key-value都以HashEntry实例存入到该数组中，若有哈希冲突，HashEntry是个链表，以链地址法解决即将哈希地址相同的key，放入到同一个链表中。

put or get or remove主要步骤：

  1. 根据key的哈希码再哈希。int hash = hash(key.hashCode())
  2. 根据新哈希码找到对应segment。segmentFor(hash)
  3. 在对应segment中计算HashEntry的索引 int index = hash & (tab.length - 1);
  4. 遍历对应 HashEntry[] table的table[index]
  5. 匹配HashEntry的哈希码，及key，匹配成功进行对应操作。

jdk1.8新变化：

  1. Segment改为Node，锁住node来实现减小锁粒度。
  2. synchronize替代了ReentrantLock。
  3. 利用Unsafe的CAS，实现无锁化的修改值的操作。
  4. Node中next去掉了final修饰，增加了violate修饰，避免了remove后clone问题。
  5. 设计了MOVED状态 当resize的中过程中 线程2还在put数据，线程2会帮助resize。
  6. 当链表节点大于等于8时，把链表节点包装成TreeNode放在TreeBin对象中，由TreeBin完成对红黑树的包装。
Believe勤能补拙
关注
专栏目录
Java 集合框架：HashMap 的介绍、使用、原理与源码解析
栗筝i的博客
07-23 7000
HashMap 根据是一个键值对集合，采用 hashCode 值存储数据，大多数情况下可以直接定位到它的值，因而具有很快的访问速度，但遍历顺序却是不确定的。HashMap 最多只允许一条记录的键为 null。HashMap 非线程安全，即任一时刻可以有多个线程同时写 HashMap，可能会导致数据的不一致。如果需要满足线程安全，可以用 Collections 的 synchronizedMap 方法使 HashMap 具有线程安全的能力，或者使用 ConcurrentHashMap。
Java常用集合
04-01
Java常用集合的思维导图
Java 常见集合
竹锋的风的博客
05-16 756
Java 集合是 Java 提供的一种容器，可以用来存储多个数据。Java 集合通常存放的是对象的引用，而不是对象本身。Java 集合主要分为 Set、List、Queue 和 Map 四种接口类型。
Java 入门指南：Java 并发编程 —— 并发容器 ConcurrentHashMap
最新发布
Zachyy的博客
09-03 1289
ConcurrentHashMap 是线程安全的，支持完全并发的读取，并且有很多线程可以同时执行写入。在早期版本（例如 JDK 1.7）中，ConcurrentHashMap 使用分段锁技术。整个哈希表被分成一些段（Segment），每个段独立加锁。这样，在不同段上的操作可以并发进行。 从 JDK 1.8 开始，ConcurrentHashMap 的内部实现有了很大的变化。它放弃了分段锁技术，转而采用了更先进的并发控制策略，如 CAS 操作和红黑树等，进一步提高了并发性能。
JAVA常见集合
三七益生菌的博客
06-21 188
List,Set,Map区别
java常见集合
m0_66971047的博客
10-29 775
Java常见集合
Java中的常见集合
weixin_45804384的博客
01-03 614
集合框架、继承结构、List框架的概况。通过查看List源代码学习其底层结构和设计思路，重点学习了ArrayList的构造器和方法。
JAVA集合框架详解：Collection与Map接口及其子类
"JAVA集合框架概述，包括其由来、主要接口Collection和Map，以及相关实现类的特点和线程安全性" JAVA集合框架是JAVA编程中一个至关重要的组件，它为开发者提供了一套标准的数据结构和操作接口，简化了数据处理的...
Java并发集合框架深度剖析：ConcurrentHashMap与CopyOnWriteArrayList的高效使用
[Java并发集合框架深度剖析：ConcurrentHashMap与CopyOnWriteArrayList的高效使用](https://codepumpkin.com/wp-content/uploads/2017/09/ConcurrentHashMap.jpg.webp) # 1. Java并发集合框架概述 在现代软件开发中...
Java并发集合深入解析：ConcurrentHashMap与CopyOnWriteArrayList
- `HashMap`在JDK 1.2作为集合框架的一部分引入，提供更高的性能，但它本身不是线程安全的。为了在多线程环境下使用，开发者可以使用`Collections.synchronizedMap`将HashMap包装成线程安全的。这种方法允许不需要...
【Java并发集合实战】：ConcurrentHashMap原理与高效并发编程
[【Java并发集合实战】：ConcurrentHashMap原理与高效并发编程](https://dz2cdn1.dzone.com/storage/temp/12809213-lru-cache-put.png) # 1. 并发编程基础介绍 ## 1.1 并发编程的必要性 在多核处理器普及的今天，...
Java中常见的集合
youngjre的博客
02-14 532
Java中常见的集合 一、Collection 1、List(有序，可重复) ArrayList 内部是通过数组实现（缺点是每个元素之间不能有间隔） 有序，可重复 当从ArrayList中间进行插入或者删除元素时，需要对数组进行复制，移动，代价很高 随机查找和遍历的速度很快，不适合插入和删除。 LinkedList 内部通过链表实现 有序，可重复 由于是通过链表实现**，动态的插入和删除比较方便，随机访问和遍历的速度比较慢** Vertor 内部通过数组进行实现 与ArrayList不同的支持线程
java常用集合
lisha006的专栏
09-25 341
首先请区分Collections ， 它只是集合操作的工具类。 下面一张图展示常用List、Set 集合 下面一张图展示常用Map集合族谱     常用集合随笔         List        List之下需要注意的集合实现在ArrayList 、 LinkedLIst、Vector下的Stack。       存储元素的特点：有序可重复，有序即入和出顺序一致。 ...
Java常见集合一览表
yangfang的博客
06-11 1134
Java中集合种类多，功能以及特性各异，为了便于记忆和使用，花了一些时间制作了一种Java常见集合一览表。 Java常见集合一览表 集合 接口/类 K/E V 是否线程安全 说明 Collection 接口 N/A N/A N/A 定义了集合的基本方法，如size、isEmpty等 Vector 类 可为null N/A
JAVA 常见集合总结
weixin_37601506的博客
03-12 719
Java常用集合 一、数据结构 1、数组 时间负载度为o(1),空间复杂度为哦o(n) ，所以查询比较快，删除，插入、更新比较慢 2、链表 时间复杂度为o(n)因为要一条一条去比较，空间复杂度为o(1),所以查询比较慢，删除，插入、更新比较快 3、Hash表 所有复杂度都为o(1),唯一不好有hash冲突，但它不是有序的，无法进行范围查询 4、二叉树 对一棵相对平衡的有序二叉树，对其进行插入，查找，删除等操作，平均复杂度均为O(logn) 5、红黑树（平衡树） 平衡树虽然也很好，但它每一次的插入和删除都可能
java中常用的集合
qq_62898618的博客
06-29 4835
目录 几种常用的集合为什么要用集合List集合Set集合Map集合常见实现类一、HashMap底层实现原理解析Junit架包下载当我们需要操作一些类型相同的数据时，就会想到运用集合了，那为什么不用数组呢？因为Java是面向对象语言，为了操作一些对象，就得把这些对象存储起来，而集合提供的的一些API很方便我们去操作存储的Java对象。 集合的分类 1、Collection:Collection是List、Set、Queue的接口。 2、Iterator:迭代器，主要用来遍历集合。 3、Map:是映射表(键值对
Java常见的集合类（集合容器）
Yangyeon_的博客
07-18 3525
集合类型主要有三种：List（列表）、set（集）、map（映射）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值