ConcurrentHashMap1.8源码解读及如何保证线程安全

最新推荐文章于 2024-06-15 13:02:35 发布

江湖故人相逢何必曾相识

最新推荐文章于 2024-06-15 13:02:35 发布

阅读量1.1k

点赞数 3

分类专栏：集合文章标签： java

本文链接：https://blog.csdn.net/qq_41692749/article/details/108191294

版权

本文详细介绍了ConcurrentHashMap在JDK1.8中的实现，包括其摒弃分段锁后采用的node+CAS+Synchronized结构，以及put、get、扩容等操作的线程安全实现。文章深入解析了构造方法、Node、TreeNode、初始化、扩容、线程安全保障等关键点，并对比了HashMap和HashTable的区别。

摘要由CSDN通过智能技术生成

写在前面的话

不应该在意起点，而要看向将要去到的地方。

继承关系

具体解释可看之前的文章

底层结构

1.8的数据结构

摒弃了分段锁的概念，启用 node + CAS + Synchronized 代替Segment

去掉了HashEntry结构

当前的 table【(n - 1) & hash】 == null 时，采用CAS操作

当产生hash冲突时，采用synchronized关键字

内部结构和HashMap相同，仍然使用：数组 + 链表 + 红黑树

默认sizeCtl = 16，初始化时可以进行设置

基本属性

	/**
     * 最大的可能的表容量。该值必须为正好1<<30保持在Java数组分配和索引
     * 两个表大小的权限，进一步需要因为32位哈希字段的前两位用于控制目的。
     */
     //最大的容量
    private static final int MAXIMUM_CAPACITY = 1 << 30;

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

    /**
     
     */
     //最大数组大小
    static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    /**
 
     * 默认的并发度
     */
    private static final int DEFAULT_CONCURRENCY_LEVEL = 16;

    /**
    
     * 负载因子大小
     */
    private static final float LOAD_FACTOR = 0.75f;

    /**
   
     * 对象使用树而不是列表时的bin计数阈值本。当向a添加一个元素时，箱子被转换为树至少有这么多节点的bin。这个值必须更大
     * 大于2，且应至少为8，以符合假设删除关于转换回普通箱子的树收缩。
     */
     //树化的临界值
    static final int TREEIFY_THRESHOLD = 8;

    /**

     */
     //解除树化的值
    static final int UNTREEIFY_THRESHOLD = 6;

    /**
 
     * 容器可能被treeified的最小表容量。(否则，如果容器中有太多节点，将调整表的大小。)
     * 需要避免的值至少为4 * TREEIFY_THRESHOLD调整大小和treeification阈值之间的冲突。
     */
     //树化的最小容器数量
    static final int MIN_TREEIFY_CAPACITY = 64;

    /**
 
     * 每个传送步骤的最小还原次数。范围是细分以允许多个大小调整线程。
     * 这个值作为一个下界，以避免遇到大小调整器过度的内存争用。值应该是至少DEFAULT_CAPACITY。
     */
    private static final int MIN_TRANSFER_STRIDE = 16;

    /**
    
     * 用于生成戳记的位数，单位为sizeCtl。对于32位数组必须至少为6。
     */
    private static int RESIZE_STAMP_BITS = 16;

    /**

     * 可以帮助调整大小的最大线程数。必须适合32 - RESIZE_STAMP_BITS位。
     */
    private static final int MAX_RESIZERS = (1 << (32 - RESIZE_STAMP_BITS)) - 1;

    /**
  
     * 记录尺寸戳记的位位移，单位为sizeCtl。
     */
    private static final int RESIZE_STAMP_SHIFT = 32 - RESIZE_STAMP_BITS;

可以看出相比1.7,增加了树化的相关临界属性，去除了Segment的相关属性

构造方法

无参构造方法

源码

public ConcurrentHashMap() {
    }

默认大小为16

传入初始化大小的构造方法

为负数是抛出异常


    public ConcurrentHashMap(int initialCapacity) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException();
        int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
                   MAXIMUM_CAPACITY :
                   tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
        this.sizeCtl = cap;
    }

动态调整sizeCtl

调用tableSizeFor方法

保证sizeCtl必须是2的n次方

传入一个map的构造方法

sizeCtl初始化也是16，然后将map中的元素全部put进ConcurrentHashMap

public ConcurrentHashMap(Map<? extends K, ? extends V> m) {
        this.sizeCtl = DEFAULT_CAPACITY;
        putAll(m);
    }

传入初始化容量和加载因子

默认并发度为1

public ConcurrentHashMap(int initialCapacity, float loadFactor) {
        this(initialCapacity, loadFactor, 1);
    }

传入初始容量，负载因子和并发度

public ConcurrentHashMap(int initialCapacity,
                             float loadFactor, int concurrencyLevel) {
        if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0)
            throw new IllegalArgumentException();
        if (initialCapacity < concurrencyLevel)   // Use at least as many bins
            initialCapacity = concurrencyLevel;   // as estimated threads
        long size = (long)(1.0 + (long)initialCapacity / loadFactor);
        int cap = (size >= (long)MAXIMUM_CAPACITY) ?
            MAXIMUM_CAPACITY : tableSizeFor((int)size);
        this.sizeCtl = cap;
    }

输入的initialCapacity的大小来确定一个最小的且大于等于initialCapacity大小的2的n次幂，

如initialCapacity为15，则sizeCtl为16，若initialCapacity为16，则sizeCtl为16。

若initialCapacity大小超过了允许的最大值，则sizeCtl为最大值。

值得注意的是，构造函数中的concurrencyLevel参数已经在JDK1.8中的意义发生了很大的变化，其并不代表所允许的并发数，

其只是用来确定sizeCtl大小，在JDK1.8中的并发控制都是针对具体的桶而言，即有多少个桶就可以允许多少个并发数。

Node介绍

源码

static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;    //key的hash值
        final K key;       //key
        volatile V val;    //value
        volatile Node<K,V> next; //表示链表中的下一个节点

        Node(int hash, K key, V val, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.val = val;
            this.next = next;
        }
        public final K getKey()       { return key; }
        public final V getValue()     { return val; }
        public final int hashCode()   { return key.hashCode() ^ val.hashCode(); }
    }

这是1.8中构成每个元素的基本类

TreeNode

构造树的节点

static final class TreeNode<K,V> extends Node<K,V> {
        TreeNode<K,V> parent;  // red-black tree links
        TreeNode<K,V> left;
        TreeNode<K,V> right;
        TreeNode<K,V> prev;    // needed to unlink next upon deletion
        boolean red;

        TreeNode(int hash, K key, V val, Node<K,V> next,
                 TreeNode<K,V> parent) {
            super(hash, key, val, next);
            this.parent = parent;
        }
}

TreeBin介绍

源码：

static final class TreeBin<K,V> extends Node<K,V> {
        TreeNode<K,V> root;
        volatile TreeNode<K,V> first;
        volatile Thread waiter;
        volatile int lockState;
        // values for lockState
        static final int WRITER = 1; // set while holding write lock //表示持有写锁
        static final int WAITER = 2; // set when waiting for write lock //表示在等待写锁
        static final int READER = 4; // increment value for setting read lock//表示正在设置读说
}

用作树的头结点，只存储root和first节点，不存储节点的key、value值。

ForwardingNode

在转移的时候放在头部的节点，是一个空节点

static final class ForwardingNode<K,V> extends Node<K,V> {
        final Node<K,V>[] nextTable;
        ForwardingNode(Node<K,V>[] tab) {
            super(MOVED, null, null, null);
            this.nextTable = tab;
        }
}

常用方法

put

调用putVal方法，并且putVal的第三个参数设置为false

当设置为false的时候表示这个value一定会设置

true的时候，只有当这个key的value为空的时候才会设置

public V put(K key, V value) {
        return putVal(key, value, false);
    }

putVal方法

	final V putVal(K key, V value, boolean onlyIfAbsent) {
        if (key == null || value == null) throw new NullPointerException(); // 键或值为空，抛出异常
        // 键的hash值经过计算获得hash值
        int hash = spread(key.hashCode());
        int binCount = 0;
        for (Node<K,V>[] tab = table;;) { // 无限循环
            Node<K,V> f; int n, i, fh;
            if (tab == null || (n = tab.length) == 0) // 表为空或者表的长度为0
                // 初始化表
                tab = initTable();
            else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) { // 表不为空并且表的长度大于0，并且该桶不为空
                if (casTabAt(tab, i, null,
                             new Node<K,V>(hash, key, value, null))) // 比较并且交换值，如tab的第i项为空则用新生成的node替换
                    break;                   // no lock when adding to empty bin
            }
            else if ((fh = f.hash) == MOVED) // 该结点的hash值为MOVED
                // 进行结点的转移（在扩容的过程中）
                tab = helpTransfer(tab, f);
            else {
                V oldVal = null;
                synchronized (f) { // 加锁同步
                    if (tabAt(tab, i) == f) { // 找到table表下标为i的节点
                        if (fh >= 0) { // 该table表中该结点的hash值大于0
                            // binCount赋值为1
                            binCount = 1;
                            for (Node<K,V> e = f;; ++binCount) { // 无限循环
                                K ek;
                                if (e.hash == hash &&
                                    ((ek = e.key) == key ||
                                     (ek != null && key.equals(ek)))) { // 结点的hash值相等并且key也相等
                                    // 保存该结点的val值
                                    oldVal = e.val;
                                    if (!onlyIfAbsent) // 进行判断
                                        // 将指定的value保存至结点，即进行了结点值的更新
                                        e.val = value;
                                    break;
                                }
                                // 保存当前结点
                                Node<K,V> pred = e;
                                if ((e = e.next) == null) { // 当前结点的下一个结点为空，即为最后一个结点
                                    // 新生一个结点并且赋值给next域
                                    pred.next = new Node<K,V>(hash, key,
                                                              value, null);
                                    // 退出循环
                                    break;
                                }
                            }
                        }
                        else if (f instanceof TreeBin) { // 结点为红黑树结点类型
                            Node<K,V> p;
                            // binCount赋值为2
                            binCount = 2;
                            if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
                                                           value)) != null) { // 将hash、key、value放入红黑树
                                // 保存结点的val
                                oldVal = p.val;
                                if (!onlyIfAbsent) // 判断

最低0.47元/天解锁文章

江湖故人相逢何必曾相识

关注

3
点赞
踩
4

收藏

觉得还不错? 一键收藏
2
评论
ConcurrentHashMap1.8源码解读及如何保证线程安全

写在前面的话不应该在意起点，而要看向将要去到的地方。继承关系具体解释可看之前的文章底层结构1.8的数据结构摒弃了分段锁的概念，启用 node + CAS + Synchronized 代替Segment去掉了HashEntry结构当前的 table【(n - 1) & hash】 == null 时，采用CAS操作当产生hash冲突时，采用synchronized关键字内部结构和HashMap相同，仍然使用：数组 + 链表 + 红黑树默认sizeCtl = 16，初始
复制链接

扫一扫

专栏目录