源码之ConcurrentHashMap

Posted 保护眼睛

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了源码之ConcurrentHashMap相关的知识,希望对你有一定的参考价值。

源码之ConcurrentHashMap

初始化

核心成员变量和HashMap是类似的(可以看我的这篇)、ConcurrentHashMap是HashMap的线程安全版本(Collections.synchronizedMap、Hashtable也是HashMap线程安全的版本)。
初始的容量要是2的次幂:

1.如果数组的长度是2的次幂的话、那么在进行取模的运算的时候、就可以使用位运算来代替%:


2.如果数组的长度是2 的次幂的话、那么在扩容的时候(扩容也是2倍扩容)、就不需要重新利用hash函数来计算元素在新数组的位置了

那么如果是32长度的数组的话、只是看后五位即可、那么有没有更好的方法呢?
那就是只看第五位是否是0 还是1 即可、如果是 0 的话、计算出的位置还是和原来的位置是一样的、元素在原数组的位置就是新数组的位置、如果第五位的值是 1的话、那么原来的位置就是原数组的位置+原数组的长度的值、这就是源码中的实现方式。

数组是什么时候初始化的呢?
是在放入第一个元素的时候进行初始化的👇

所以来看put方法👇

put方法

1.根据key得到hashcode
2.判断是否要进行初始化的操作
3.根据key定位的Node、如果为空的话表示当前位置可以写入数据、利用的是CAS机制、如果失败的话自旋保证成功
4.判断是否要进行扩容
5.如果不满足的话、利用synchronized来写入数据
6.如果hashMap中所有节点的数量大于则要转为红黑树

初始化方法:确保只有一个线程在做初始化的操作、如果数组还没有初始化的话、稍后的线程就会让出CPU的执行权

如果当前的位置为null的话直接使用casTabAt方法来插入值

来看casTabAt方法
调用的是compareAndSwapObject方法、再点过去:

原来调用的

Unsafe类中的Native方法:那么来看Unfase类👇
Unsafe是位于sun.misc包下的一个类,主要提供一些用于执行低级别、不安全操作的方法,如直接访问系统内存资源、自主管理内存资源等,这些方法在提升Java运行效率、增强Java语言底层资源操作能力方面起到了很大的作用。但由于Unsafe类使Java语言拥有了类似C语言指针一样操作内存空间的能力,这无疑也增加了程序发生相关指针问题的风险。在程序中过度、不正确使用Unsafe类会使得程序出错的概率变大,使得Java这种安全的语言变得不再“安全”,因此对Unsafe的使用一定要慎重。

接下来就要看是否扩容👇

再就是利用synchronized来写入数据、如果hashMap中所有节点的数量大于则要转为红黑树

在插入元素完成之后还要判断是否扩容

如果要扩容的话那么就会进入transfer函数

那么元素迁移的时候要用单线程去完成元素的迁移的工作吗?
如果为了效率的话、那么就可以使用多线程来完成数据的迁移的工作、但是使用多线程的时候不能有线程不安全的问题发生。
使用多线程完成数组的迁移的时候、让每个线程迁移的桶的数量不少于16个、假设如果数组的有元素的位置是128个的话、那么就可以使用8个线程去并行的迁移数组中的元素。也就是将原来的数组分段、交给不同的线程去完成数组的迁移
根据计算机的CPU的核数计算线程的数量
这就是我们前面所讲的二倍扩容👇
初始时新的数组、二倍扩容、nextTable是新的数组、transferIndex是原数组的下标、迁移数组元素的时候是从右往左迁移的数组在迁移的时候也是使用synchronized修饰的👇

来看迁移的细节

也就是我们初始化的时候讲的、看对应位是否是0 还是 1
其中的ln表示的是对应位为0、hn表示的是对应位为1的数组元素的迁移
然后调用Unsafe中的
public native void putObjectVolatile(Object var1, long var2, Object var4);方法来实现元素的迁移
当然还有如果是红黑树时候的迁移:

相关源码(JDK1.8)

put方法

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

    /** Implementation for put and putIfAbsent */
    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)
                tab = initTable();
            else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) 
                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;
                synchronized (f) 
                    if (tabAt(tab, i) == f) 
                        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) 
                    if (binCount >= TREEIFY_THRESHOLD)
                        treeifyBin(tab, i);
                    if (oldVal != null)
                        return oldVal;
                    break;
                
            
        
        addCount(1L, binCount);
        return null;
    

初始化方法initTable

    private final Node<K,V>[] initTable() 
        Node<K,V>[] tab; int sc;
        while ((tab = table) == null || tab.length == 0) 
            if ((sc = sizeCtl) < 0)
                Thread.yield(); // lost initialization race; just spin
            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;
    

扩容方法transfer

private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) 
        int n = tab.length, stride;
        if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
            stride = MIN_TRANSFER_STRIDE; // subdivide range
        if (nextTab == null)             // initiating
            try 
                @SuppressWarnings("unchecked")
                Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
                nextTab = nt;
             catch (Throwable ex)       // try to cope with OOME
                sizeCtl = Integer.MAX_VALUE;
                return;
            
            nextTable = nextTab;
            transferIndex = n;
        
        int nextn = nextTab.length;
        ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
        boolean advance = true;
        boolean finishing = false; // to ensure sweep before committing nextTab
        for (int i = 0, bound = 0;;) 
            Node<K,V> f; int fh;
            while (advance) 
                int nextIndex, nextBound;
                if (--i >= bound || finishing)
                    advance = false;
                else if ((nextIndex = transferIndex) <= 0) 
                    i = -1;
                    advance = false;
                
                else if (U.compareAndSwapInt
                         (this, TRANSFERINDEX, nextIndex,
                          nextBound = (nextIndex > stride ?
                                       nextIndex - stride : 0))) 
                    bound = nextBound;
                    i = nextIndex - 1;
                    advance = false;
                
            
            if (i < 0 || i >= n || i + n >= nextn) 
                int sc;
                if (finishing) 
                    nextTable = null;
                    table = nextTab;
                    sizeCtl = (n << 1) - (n >>> 1);
                    return;
                
                if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) 
                    if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
                        return;
                    finishing = advance = true;
                    i = n; // recheck before commit
                
            
            else if ((f = tabAt(tab, i)) == null)
                advance = casTabAt(tab, i, null, fwd);
            else if ((fh = f.hash) == MOVED)
                advance = true; // already processed
            else 
                synchronized (f) 
                    if (tabAt(tab, i) == f) 
                        Node<K,V> ln, hn;
                        if (fh >= 0) 
                            int runBit = fh & n;
                            Node<K,V> lastRun = f;
                            for (Node<K,V> p = f.next; p != null; p = p.next) 
                                int b = p.hash & n;
                                if (b != runBit) 
                                    runBit = b;
                                    lastRun = p;
                                
                            
                            if (runBit == 0) 
                                ln = lastRun;
                                hn = null;
                            
                            else 
                                hn = lastRun;
                                ln = null;
                            
                            for (Node<K,V> p = f; p != lastRun; p = p.next) 
                                int ph = p.hash; K pk = p.key; V pv = p.val;
                                if ((ph & n) == 0)
                                    ln = new Node<K,V>(ph, pk, pv, ln);
                                else
                                    hn = new Node<K,V>(ph, pk, pv, hn);
                            
                            setTabAt(nextTab, i, ln);
                            setTabAt(nextTab, i + n, hn);
                            setTabAt(tab, i, fwd);
                            advance = true;
                        
                        else if (f instanceof TreeBin) 
                            TreeBin<K,V> t = (TreeBin<K,V>)f;
                            TreeNode<K,V> lo = null, loTail = null;
                            TreeNode<K,V> hi = null, hiTail = null;
                            int lc = 0, hc = 0;
                            for (Node<K,V> e = t.first; e != null; e = e.next) 
                                int h = e.hash;
                                TreeNode<K,V> p = new TreeNode<K,V>
                                    (h, e.key, e.val, null, null);
                                if ((h & n) == 0) 
                                    if ((p.prev = loTail) == null)
                                        lo = p;
                                    else
                                  

以上是关于源码之ConcurrentHashMap的主要内容,如果未能解决你的问题,请参考以下文章

源码之ConcurrentHashMap

源码之ConcurrentHashMap

死磕 java集合之ConcurrentHashMap源码分析

死磕 java集合之ConcurrentHashMap源码分析

死磕 java集合之ConcurrentHashMap源码分析

JUCJDK1.8源码分析之ConcurrentHashMap