黑马-ConcurrentHashMap

HashMap和CurrentHashMap有关的位移操作

1、HashMap

HashMap中获取根据传入的key获取元素位置的时候,会先获取key的hash值(用key的hashCode异或上key右移16位的二进制值),再将获取到的hash值与table.lenth-1相与,即可获得key元素在table的位置

static final int hash(Object key){
	int h;
	return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16)
}

目的是为了让key的hash值得高16位也参与计算

HashMap面试题
JDK1.7死循环的产生

2、CurrentHashMap

JDK1.8中,对给定的初始化大小,用它本身加上它右移两位的值再加上1的值,再去获取一个2的整次幂的数

public ConcurrentHashMap(int initialCapacity) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException();
        int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
                   MAXIMUM_CAPACITY :
                   // 用它本身加上它右移两位的值再加上1的值,再去获取一个2的整次幂的数
                   tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
        this.sizeCtl = cap;
    }

JDK1.8中,对于sizeCtl的值为-N时,取对应的二进制的低16位数值为M,代表此时有M-1个扩容线程。而并不代表有N-1个线程

CurrentHashMap

JDK1.7

1、思想

ConcurrentHashMap将数据分成一段一段地存储,然后给每一段数据配一把锁,当一个线程占用的锁访问其中一个段数据的时候,其他段的数据也能被其他线程访问

2、结构

CurrentHashMap是由Segment数组结构和HashEntry数组结构组成。Segment是一种可重入锁,在CurrentHashMap里扮演锁的角色HashEntry则用于存储键值对数据。一个CurrentHashMap里包含一个Segment数组。Segment的结构和HashMap类似,是一种数组和链表结构。一个Segment里包含一个HashEntry数组,每个HashEntry是一个链表结构的元素,每个Segment守护着一个HashEntry数组里的元素,当对HashEntry数组的数据进行修改时,必须首先获得与他对应的Segment锁。

在这里插入图片描述

3、初始化segment

3.1初始化segment数组

segment数组的长度是ssize通过concurrencyLevel(并发等级)计算得出的。为了能够通过按位与的散列算法定位segment数组的索引,必须保证segment数组的长度是2的N次方,所以必须计算出一个大于或等于concurrencyLevel的最小的2的N次方的值所谓segment数组的长度。

3.2初始化segmentShift和segmentMask

segmentShift和segmentMask这两个变量需要在定位segment数组时的散列算法里使用。

3.3初始化每个segment

由于每个segment里面是HashEntry数组,所以这一步也就是初始化HashEntry。构造函数中initialCapacity就是HashEntry数组的初始长度。

4、定位segment

既然ConcurrentHashMap是使用分段锁segment来保护不同的数据,那么在插入和获取元素的时候,必须先通过散列算法定位到segment。ConcurrentHashMap会首先使用Wang/Jenkins hash额变种算法对元素进行一次再散列,目的是减少散列冲突。

5、ConcurrentHashMap的操作

5.1get操作

segment的get操作非常简单和高效,只需要通过一次再散列就可以定位到HashEntry,再通过一次散列就可以找到对应的元素。

get操作的高效之处在于整个get过程不需要加锁,除非读取到的值是空值才会加锁重读。它是如何做到的呢?原因是它的get方法里将要使用的共享变量都定义成了volatile类型,保证了线程之间的可见性,还能够被多线程同时读,并且保证不会读到过期的值(之所以不会读取到过期的值是因为基于Java内存模型的happen before原则,对volatile字段的写操作先于读操作,所以即使两个线程同时修改和获取volatile变量,get操作也能拿到最新的值)

5.2put操作

由于put操作需要对共享变量进行写入操作,所以为了线程安全,在操作共享变量时,必须加锁。put方法首先定位到segment,然后在segment进行插入操作,插入操作需要经过两个步骤:第一步是判断是否需要对HashEntry扩容,第二步是定位添加元素的位置,然后将其放在HashEntry数组里。

(1)是否需要扩容
在插入元素前会判断segment里的HashEntry是否超过阈值,如果超过阈值,则先进行扩容。值得一提的是,segment的扩容比HashMap更恰当,因为HashMap是在插入元素之后判断是否需要扩容,如果扩容之后没有添加新元素,就进行了一次无效的扩容

(2)如何扩容
在扩容的时候,首先会创建一个容量是原来两倍的数组,然后将原数组里的元素进行再散列后插入到新的数组里。为了高效,ConcurrentHashMap不会对整个容器进行扩容,而只对某个segment扩容。

2、1.8

1、关于初始化

对给定的初始化大小,用它本身加上它右移两位的值再加上1的值,再去获取一个2的整次幂的数

public ConcurrentHashMap(int initialCapacity) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException();
        int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
                   MAXIMUM_CAPACITY :
                   // 用它本身加上它右移两位的值再加上1的值,再去获取一个2的整次幂的数
                   tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
        this.sizeCtl = cap;
    }

tableSizeFor方法

private static final int tableSizeFor(int c) {
        int n = c - 1;
        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
    }

2、sizeCtl含义解释

ConcurrentHashMap的构造方法中,都涉及到一个变量sizeCtl,他的值不同,对应的含义也不一样

含义
0代表数组未初始化,且数组的初始容量是16
正数如果数组未初始化,那么其记录的是数组的初始容量; 如果数组已经初始化,那么记录的是数组的扩容阈值
-1表示数组正在进行初始化
-N取对应的二进制的低16位数值为M,代表此时有M-1个扩容线程。而并不代表有N-1个线程

3、初始化

第一次put操作,会先判断一下table数组为空,如果为空,则先进行table初始化,table初始化时,先判断sizeCtl的值,如果小于0则表示有其他线程正在初始化,自己就让出CPU执行权,否则就开始初始化,初始化采用cas方法方式,尝试将sizeCtl更新为-1,告知其他线程我正在初始化,下面会进行double check,确保table没有被初始化,初始化完成之后更新sizeCtl,这时候这个sizeCtl大于0,代表的是下一次需要扩容的table阈值。如果不需要初始化table,就计算key的hash值,找到对象的node,如果node为null用cas的方式插入node,如果不为null且node的hash值为-1,代表正在扩容,则加入扩容的队伍,如果没有在扩容,就加入node,注意,加入的时候对node加了sync锁,锁的就是这个node,这个过程会判断fh得值,判断插入的是连表还是红黑树。

final V putVal(K key, V value, boolean onlyIfAbsent) {
        if (key == null || value == null) throw new NullPointerException();
        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)
            	// 初始化node数组
                tab = initTable();
            // 插入元素会先根据key的hash值取出对应的node,如果node为null,则直接加入
            else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            	// 加入同样使用cas
                if (casTabAt(tab, i, null,
                             new Node<K,V>(hash, key, value, null)))
                    break;                   // no lock when adding to empty bin
            }
            else if ((fh = f.hash) == MOVED)
                tab = helpTransfer(tab, f);
            else {
                V oldVal = null;
                //使用sync关键字保证线程安全性,sync锁的是当前node节点,锁的粒度小了,
                //就不会影响其他node节点的插入了(对比hashmap,锁的是整个数组,锁粒度太大)
                synchronized (f) {
                    if (tabAt(tab, i) == f) {
                    	/*
                    	当fh大于0时,代表当前是链表,插入式循环遍历其他链表元素,如果不相等就采用尾插法插入链表
						当不大于0时,代表不是链表结构,是红黑树,新数据则插入红黑树
                    	*/
                        if (fh >= 0) {
                            binCount = 1;
                            for (Node<K,V> e = f;; ++binCount) {
                                K ek;
                                if (e.hash == hash &&
                                    ((ek = e.key) == key ||
                                     (ek != null && key.equals(ek)))) {
                                    oldVal = e.val;
                                    if (!onlyIfAbsent)
                                        e.val = value;
                                    break;
                                }
                                Node<K,V> pred = e;
                                if ((e = e.next) == null) {
                                    pred.next = new Node<K,V>(hash, key,
                                                              value, null);
                                    break;
                                }
                            }
                        }
                        else if (f instanceof TreeBin) {
                            Node<K,V> p;
                            binCount = 2;
                            if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
                                                           value)) != null) {
                                oldVal = p.val;
                                if (!onlyIfAbsent)
                                    p.val = value;
                            }
                        }
                    }
                }
                if (binCount != 0) {
	                // 添加完之后会进行判断,如果链表长度大于8且数组长度大于64,会进行树化操作
                    if (binCount >= TREEIFY_THRESHOLD)
                        treeifyBin(tab, i);
                    if (oldVal != null)
                        return oldVal;
                    break;
                }
            }
        }
        // 这个方法做两件事:1、维护集合的长度 2、判断集合的长度是否超过了阈值,超过了就进行扩容
        addCount(1L, binCount);
        return null;
    }

数组初始化

private final Node<K,V>[] initTable() {
        Node<K,V>[] tab; int sc;
        while ((tab = table) == null || tab.length == 0) {
        	// 这里就用到了关键的sizeCtl,小于0代表正在初始化或者扩容
        	// 这里是初始化方法,肯定是初始化,
            if ((sc = sizeCtl) < 0)
            	// 当一个线程进来时,发现正在初始化,那就让出CPU执行权,
            	// 第一个线程进来肯定不会走这里
                Thread.yield(); // lost initialization race; just spin
            // 线程开始初始化,同时使用cas的方式将sizeCtl改为-1
            else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
                try {
                    if ((tab = table) == null || tab.length == 0) {
                    	// 设置初始容量
                        int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
                        @SuppressWarnings("unchecked")
                        Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
                        table = tab = nt;
                        sc = n - (n >>> 2);
                    }
                } finally {
                    sizeCtl = sc;
                }
                break;
            }
        }
        return tab;
    }

4、ConcurrentHashMap的操作

点击查看

5、其他

5.1关于hash值

put()之前会先计算key的hash值,计算的这个值一定是一个正数,方便添加元素判断该节点的类型

int hash = spread(key.hashCode());
5.2插入元素是如何保证线程安全的

使用sync关键字保证线程安全性,sync锁的是当前node节点,锁的粒度小了,就不会影响其他node节点的插入了(对比hashmap,锁的是整个数组,锁粒度太大)

5.3关于fh(标识是链表还是红黑树)

当fh大于0时,代表当前是链表,插入式循环遍历其他链表元素,如果不相等就采用尾插法插入链表

当不大于0时,代表不是链表结构,是红黑树,新数据则插入红黑树

5.4、扩容

首先判断数组是不是空的,如果数组是空的,先去创建数组,如果数组正在被创建,则尝试对baseCount++,如果加成功,就结束,如果不成功,则进行自旋操作,直到加成功。如果数组不为空,首先判断这个位置是否有对象,没有对象则创建counterCell对象,对counterCell里面的value++,成功结束循环,如果不为空,判断是否冲突,冲突的话重新计算线程的哈希值,再从头循环,选择不同的counterCell,不冲突则尝试累加counterCell中的value


扩容表示戳计算方式?
保证在同一条件下,不同线程来了,计算出的戳是一致的

如何保证写数据的线程安全?

hash寻址算法?

先计算最小的任务量就是要迁移的数组的长度,默认为16

数组的节点值为fwd(-1)或者hashCode为MOVED,代表这个节点正在扩容并且数据正在迁移

当一个数组迁移完,那么所有位置都为fwd,则再次进行分配,去迁移其他数据

如何判断线程是否全部完成扩容了呢?
sc == (resizeStamp(n) << RESIZE_STAMP_SHIFT) + 2

扩容完开始迁移

如果数组数组为空,直接给数组一个fwd,说明已经迁移完

迁移的时候使用到了sync,锁的也是node节点,迁移的逻辑和JDK1.7一样

  • 1
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值