ConcurrentHashMap原理解析

最新推荐文章于 2024-06-06 09:47:22 发布
最新推荐文章于 2024-06-06 09:47:22 发布
阅读量334 收藏
点赞数
分类专栏： 源码 文章标签： java 源码 jdk1.8
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/More_speed/article/details/115796548
版权
一、必备知识
  • JDK1.7 ConcurrentHashMap使用锁分段技术，由Segment数组结构和HashEntry数组结构组成。Segment是一种可重入锁ReentrantLock，在ConcurrentHashMap里扮演锁的角色，HashEntry则用于存储键值对数据。一个ConcurrentHashMap里包含一个Segment数组，Segment的结构和HashMap类似，是一种数组和链表结构， 一个Segment里包含一个HashEntry数组，每个HashEntry是一个链表结构的元素， 每个Segment守护着一个HashEntry数组里的元素，当对HashEntry数组的数据进行修改时，必须首先获得它对应的Segment锁。（网络图片如下所示）img
  • JDK1.8 的实现已经摒弃了Segment的概念，而是直接用Node数组+链表+红黑树的数据结构来实现，并发控制使用Synchronized和CAS来操作，整个看起来就像是优化过且线程安全的HashMap，虽然在JDK1.8中还能看到Segment的数据结构，但是已经简化了属性，只是为了兼容旧版本。
二、JDK1.8源码阅读
1.属性
  // node数组最大容量：2^30=1073741824  
  private  static  final  int  MAXIMUM_CAPACITY =  1  <<  30 ;  

  // 默认初始值，必须是2的幂数  
  private  static  final  int  DEFAULT_CAPACITY =  16 ;  

  //数组可能最大值，需要与toArray（）相关方法关联  
  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;  

  // 链表转红黑树阀值,> 8 链表转换为红黑树  
  static  final  int  TREEIFY_THRESHOLD =  8 ;  

  //树转链表阀值，小于等于6（tranfer时，lc、hc=0两个计数器分别++记录原bin、新binTreeNode数量，<=UNTREEIFY_THRESHOLD 则untreeify(lo)）  
  static  final  int  UNTREEIFY_THRESHOLD =  6  ;  
  static  final  int  MIN_TREEIFY_CAPACITY =  64 ;  
  private  static  final  int  MIN_TRANSFER_STRIDE =  16 ;  
  private  static  int  RESIZE_STAMP_BITS =  16 ;  

  // 2^15-1，help resize的最大线程数  
  private  static  final  int  MAX_RESIZERS = (  1  << (  32  - RESIZE_STAMP_BITS)) -  1 ;  

  // 32-16=16，sizeCtl中记录size大小的偏移量  
  private  static  final  int  RESIZE_STAMP_SHIFT =  32 - RESIZE_STAMP_BITS;  

  // forwarding nodes的hash值  
  static  final  int  MOVED     = -1 ;  

  // 树根节点的hash值  
  static  final  int  TREEBIN   = -2 ;  

  // ReservationNode的hash值  
  static  final  int  RESERVED  = -3 ;  

  // 可用处理器数量  
  static  final  int  NCPU = Runtime.getRuntime().availableProcessors();  

  //存放node的数组  
  transient  volatile  Node<K,V>[] table;  

  /*控制标识符，用来控制table的初始化和扩容的操作，不同的值有不同的含义  
  *当为负数时：-1代表正在初始化，-N代表有N-1个线程正在进行扩容  
  *当为0时：代表当时的table还没有被初始化  
  *当为正数时：表示初始化或者下一次进行扩容的大小  
  */
  private  transient  volatile  int  sizeCtl;
2.内部类

  • Node

    	static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
    	//val和next都会在扩容时发生变化，所以加上volatile来保持可见性和禁止重排序  
        volatile V val;
        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(); }
        public final String toString(){ return key + "=" + val; }
    	//不允许更新value  
        public final V setValue(V value) {
            throw new UnsupportedOperationException();
        }

        public final boolean equals(Object o) {
            Object k, v, u; Map.Entry<?,?> e;
            return ((o instanceof Map.Entry) &&
                    (k = (e = (Map.Entry<?,?>)o).getKey()) != null &&
                    (v = e.getValue()) != null &&
                    (k == key || k.equals(key)) &&
                    (v == (u = val) || v.equals(u)));
        }

        //用于map中的get()方法，子类重写 
        Node<K,V> find(int h, Object k) {
            Node<K,V> e = this;
            if (k != null) {
                do {
                    K ek;
                    if (e.hash == h &&
                        ((ek = e.key) == k || (ek != null && k.equals(ek))))
                        return e;
                } while ((e = e.next) != null);
            }
            return null;
        }
    }

  • 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;
        }

        Node<K,V> find(int h, Object k) {
            return findTreeNode(h, k, null);
        }

        //根据key查找,从根节点开始找出相应的TreeNode，        
        final TreeNode<K,V> findTreeNode(int h, Object k, Class<?> kc) {
            if (k != null) {
                TreeNode<K,V> p = this;
                do  {
                    int ph, dir; K pk; TreeNode<K,V> q;
                    TreeNode<K,V> pl = p.left, pr = p.right;
                    if ((ph = p.hash) > h)
                        p = pl;
                    else if (ph < h)
                        p = pr;
                    else if ((pk = p.key) == k || (pk != null && k.equals(pk)))
                        return p;
                    else if (pl == null)
                        p = pr;
                    else if (pr == null)
                        p = pl;
                    else if ((kc != null ||
                              (kc = comparableClassFor(k)) != null) &&
                             (dir = compareComparables(kc, k, pk)) != 0)
                        p = (dir < 0) ? pl : pr;
                    else if ((q = pr.findTreeNode(h, k, kc)) != null)
                        return q;
                    else
                        p = pl;
                } while (p != null);
            }
            return null;
        }
    }

  • TreeBin(TreeBin就是封装TreeNode的容器，它提供转换红黑树的一些条件和锁的控制)

    	static final class TreeBin<K,V> extends Node<K,V> {
        //指向TreeNode列表和根节点
        TreeNode<K,V> root;
        volatile TreeNode<K,V> first;
        volatile Thread waiter;
        volatile int lockState;
        // 读写锁状态 
        static final int WRITER = 1; // 获取写锁的状态 
        static final int WAITER = 2; // 等待写锁的状态  
        static final int READER = 4; // 增加数据时读锁的状态
        
        //初始化红黑树
        TreeBin(TreeNode<K,V> b) {
            super(TREEBIN, null, null, null);
            this.first = b;
            TreeNode<K,V> r = null;
            for (TreeNode<K,V> x = b, next; x != null; x = next) {
                next = (TreeNode<K,V>)x.next;
                x.left = x.right = null;
                if (r == null) {
                    x.parent = null;
                    x.red = false;
                    r = x;
                }
                else {
                    K k = x.key;
                    int h = x.hash;
                    Class<?> kc = null;
                    for (TreeNode<K,V> p = r;;) {
                        int dir, ph;
                        K pk = p.key;
                        if ((ph = p.hash) > h)
                            dir = -1;
                        else if (ph < h)
                            dir = 1;
                        else if ((kc == null &&
                                  (kc = comparableClassFor(k)) == null) ||
                                 (dir = compareComparables(kc, k, pk)) == 0)
                            dir = tieBreakOrder(k, pk);
                            TreeNode<K,V> xp = p;
                        if ((p = (dir <= 0) ? p.left : p.right) == null) {
                            x.parent = xp;
                            if (dir <= 0)
                                xp.left = x;
                            else
                                xp.right = x;
                            r = balanceInsertion(r, x);
                            break;
                        }
                    }
                }
            }
            this.root = r;
            assert checkInvariants(root);
        }
    }
3.方法

  • 构造方法

        //空的构造
    public ConcurrentHashMap() {
    }
    //如果在实例化对象的时候指定了容量，则初始化sizeCtl
    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;
    }
    //当出入一个Map的时候，先设定sizeCtl为默认容量，在添加元素
    public ConcurrentHashMap(Map<? extends K, ? extends V> m) {
            this.sizeCtl = DEFAULT_CAPACITY;
            putAll(m);
    }

    可以看到，在任何一个构造方法中，都没有对存储Node的table变量进行初始化。而是在第一次put操作的时候在进行初始化。

  • putVal方法

    	final V putVal(K key, V value, boolean onlyIfAbsent) {
        if (key == null || value == null) throw new NullPointerException();
        int hash = spread(key.hashCode());	//两次hash，减少hash冲突，可以均匀分布
        int binCount = 0;
        for (Node<K,V>[] tab = table;;) {	//对table进行迭代
            Node<K,V> f; int n, i, fh;
            //这里就是上面构造方法没有进行初始化，在这里进行判断，为null就调用initTable进行初始化，属于懒汉模式初始化
            if (tab == null || (n = tab.length) == 0)
                tab = initTable();
            else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {	//如果i位置没有数据，就直接无锁插入
                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;
                //如果以上条件都不满足，那就要进行加锁操作，也就是存在hash冲突，锁住链表或者红黑树的头结点
                synchronized (f) {
                    if (tabAt(tab, i) == f) {
                        if (fh >= 0) {		//表示该节点是链表结构
                            binCount = 1;
                            for (Node<K,V> e = f;; ++binCount) {
                                K ek;
                                //这里涉及到相同的key进行put就会覆盖原先的value
                                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时就会进行红黑树的转换
                    if (binCount >= TREEIFY_THRESHOLD)
                        treeifyBin(tab, i);
                    if (oldVal != null)
                        return oldVal;
                    break;
                }
            }
        }
        addCount(1L, binCount);				//统计size，并且检查是否需要扩容
        return null;
    }

    put的过程很清晰，对当前的table进行无条件自循环直到put成功，可以分成以下六步流程来概述

    1. 如果没有初始化就先调用initTable()方法来进行初始化过程
    2. 如果没有hash冲突就直接CAS插入
    3. 如果还在进行扩容操作就先进行扩容
    4. 如果存在hash冲突，就加锁来保证线程安全，这里有两种情况，一种是链表形式就直接遍历到尾端插入，一种是红黑树就按照红黑树结构插入
    5. 最后一个如果hash冲突时会形成Node链表，在链表长度超过8，Node数组超过64时会将链表结构转换为红黑树的结构，break再一次进入循环
    6. 如果添加成功就调用addCount()方法统计size，并且检查是否需要扩容

  • initTable方法

    	/**
     * 初始化数组table，
     * 如果sizeCtl小于0，说明别的数组正在进行初始化，则让出执行权
     * 如果sizeCtl大于0的话，则初始化一个大小为sizeCtl的数组
     * 否则的话初始化一个默认大小(16)的数组
     * 然后设置sizeCtl的值为数组长度的3/4
     */
	private final Node<K,V>[] initTable() {
        Node<K,V>[] tab; int sc;
        //第一次put的时候，table还没被初始化，进入while
        while ((tab = table) == null || tab.length == 0) {
            //sizeCtl初始值为0，当小于0的时候表示在别的线程在初始化表或扩展表
            if ((sc = sizeCtl) < 0)
                Thread.yield(); // lost initialization race; just spin
            //SIZECTL：表示当前对象的内存偏移量，sc表示期望值，-1表示要替换的值，设定为-1表示要初始化表了，这一步会将sizeCtl设置成-1
            else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
                try {
                    if ((tab = table) == null || tab.length == 0) {
                        //指定了大小的时候就创建指定大小的Node数组，否则创建指定大小(16)的Node数组
                        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长度为数组长度的3/4
                    sizeCtl = sc;
                }
                break;
            }
        }
        return tab;
    }

  • treeifyBin方法

    在putVal方法中，我们可以看到，在同一个节点的个数超过8个的时候，会调用treeifyBin方法来看看是扩容还是转化为一棵树

        	/**
         * 当数组长度小于64的时候，扩张数组长度一倍，否则的话把链表转为树
         */
        private final void treeifyBin(Node<K,V>[] tab, int index) {
            Node<K,V> b; int n, sc;
            if (tab != null) {
                if ((n = tab.length) < MIN_TREEIFY_CAPACITY)    //MIN_TREEIFY_CAPACITY 64
                    tryPresize(n << 1);        // 数组扩容
                else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {
                    synchronized (b) {    //使用synchronized同步器，将该节点出的链表转为树
                        if (tabAt(tab, index) == b) {
                            TreeNode<K,V> hd = null, tl = null;    //hd：树的头(head)
                            for (Node<K,V> e = b; e != null; e = e.next) {
                                TreeNode<K,V> p =
                                    new TreeNode<K,V>(e.hash, e.key, e.val,
                                                      null, null);
                                //把Node组成的链表，转化为TreeNode的链表，头结点任然放在相同的位置
                                if ((p.prev = tl) == null)        
                                    hd = p;    //设置head
                                else
                                    tl.next = p;
                                tl = p;
                            }
                            setTabAt(tab, index, new TreeBin<K,V>(hd));//把TreeNode的链表放入容器TreeBin中
                        }
                    }
                }
            }
        }

  • tryPresize方法

            /**
         * 扩容表为指可以容纳指定个数的大小（总是2的N次方）
         * 假设原来的数组长度为16，则在调用tryPresize的时候，size参数的值为16<<1(32)，此时sizeCtl的值为12
         */
        private final void tryPresize(int size) {
                /*
                 * MAXIMUM_CAPACITY = 1 << 30 = 1073741824
                 * 如果给定的大小大于等于数组容量的一半，则直接使用最大容量，
                 * 否则使用tableSizeFor算出来，tableSizeFor()返回值是入参的二倍
                 */
            int c = (size >= (MAXIMUM_CAPACITY >>> 1)) ? MAXIMUM_CAPACITY :
                tableSizeFor(size + (size >>> 1) + 1);
            int sc;
            while ((sc = sizeCtl) >= 0) {   // while循环来进行扩容
                Node<K,V>[] tab = table; int n;
                /*
                 * 如果数组table还没有被初始化，则初始化一个大小为sizeCtrl和刚刚算出来的c中较大的一个大小的数组
                 * 初始化的时候，设置sizeCtrl为-1，初始化完成之后把sizeCtrl设置为数组长度的3/4
                 * 为什么要在扩张的地方来初始化数组呢？这是因为调用putAll方法直接put一个map的话，在putALl方法中没有调用initTable方法去初始化table，而是直接调用了tryPresize方法，所以这里需要做一个是不是需要初始化table的判断
                 */
                if (tab == null || (n = tab.length) == 0) {
                    n = (sc > c) ? sc : c;   
                    if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {    //初始化tab的时候，把sizeCtl设为-1
                        try {
                            if (table == tab) {
                                @SuppressWarnings("unchecked")
                                Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];  // 扩容一个长度是n的新数组
                                table = nt;  // 把新数组赋值给table变量
                                sc = n - (n >>> 2);
                            }
                        } finally {
                            sizeCtl = sc;
                        }
                    }
                }
                else if (c <= sc || n >= MAXIMUM_CAPACITY) {
                        break;    
                }
                else if (tab == table) {
                    int rs = resizeStamp(n);
                    if (sc < 0) {
                        Node<K,V>[] nt;
                        if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
                            sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
                            transferIndex <= 0)
                            break;
                        if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
                            // 开始转移数据
                            transfer(tab, nt);
                    }
                    else if (U.compareAndSwapInt(this, SIZECTL, sc,
                                                 (rs << RESIZE_STAMP_SHIFT) + 2)) {
                            // 开始转移数据
                            transfer(tab, null);
                    }
                }
            }
        }

    在tryPresize方法中，并没有加锁，允许多个线程进入，如果数组正在扩张，则当前线程也去帮助扩容。

  • transfer方法

        	/**
         * Moves and/or copies the nodes in each bin to new table. See
         * above for explanation.
         * 把数组中的节点复制到新的数组的相同位置，或者移动到扩张部分的相同位置
         * 在这里首先会计算一个步长，表示一个线程处理的数组长度，用来控制对CPU的使用，
         * 每个CPU最少处理16个长度的数组元素,也就是说，如果一个数组的长度只有16,那只有一个线程会对其进行扩容的复制移动操作
         * 扩容的时候会一直遍历,直到复制完所有节点,没处理一个节点的时候会在链表的头部设置一个fwd节点,这样其他线程就会跳过他
         * 复制后在新数组中的链表不是绝对的反序的
         */
        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)    //MIN_TRANSFER_STRIDE 用来控制不要占用太多CPU
                stride = MIN_TRANSFER_STRIDE; // subdivide range    //MIN_TRANSFER_STRIDE=16
            /*
             * 如果复制的目标nextTab为null的话，则初始化一个table两倍长的nextTab
             * 此时nextTable被设置值了(在初始情况下是为null的)
             * 因为如果有一个线程开始了表的扩张的时候，其他线程也会进来帮忙扩张，
             * 而只是第一个开始扩张的线程需要初始化下目标数组
             */
            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;
            /*
             * 创建一个fwd节点，这个是用来控制并发的，当一个节点为空或已经被转移之后，就设置为fwd节点
             * 这是一个空的标志节点
             */
            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);    //设置sizeCtl为扩容后的0.75
                        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)            //数组中把null的元素设置为ForwardingNode节点(hash值为MOVED[-1])
                    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) {        //该节点的hash值大于等于0，说明是一个Node节点
                                    /*
                                     * 因为n的值为数组的长度，且是power(2,x)的，所以，在&操作的结果只可能是0或者n
                                     * 根据这个规则
                                     *         0-->  放在新表的相同位置
                                     *         n-->  放在新表的（n+原来位置）
                                     */
                                int runBit = fh & n; 
                                Node<K,V> lastRun = f;
                                /*
                                 * lastRun 表示的是需要复制的最后一个节点
                                 * 每当新节点的hash&n -> b 发生变化的时候，就把runBit设置为这个结果b
                                 * 这样for循环之后，runBit的值就是最后不变的hash&n的值
                                 * 而lastRun的值就是最后一次导致hash&n 发生变化的节点(假设为p节点)
                                 * 为什么要这么做呢？因为p节点后面的节点的hash&n 值跟p节点是一样的，
                                 * 所以在复制到新的table的时候，它肯定还是跟p节点在同一个位置
                                 * 在复制完p节点之后，p节点的next节点还是指向它原来的节点，就不需要进行复制了，自己就被带过去了
                                 * 这也就导致了一个问题就是复制后的链表的顺序并不一定是原来的倒序
                                 */
                                for (Node<K,V> p = f.next; p != null; p = p.next) {
                                    int b = p.hash & n;    //n的值为扩张前的数组的长度
                                    if (b != runBit) {
                                        runBit = b;
                                        lastRun = p;
                                    }
                                }
                                if (runBit == 0) {
                                    ln = lastRun;
                                    hn = null;
                                }
                                else {
                                    hn = lastRun;
                                    ln = null;
                                }
                                /*
                                 * 构造两个链表，顺序大部分和原来是反的
                                 * 分别放到原来的位置和新增加的长度的相同位置(i/n+i)
                                 */
                                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)
                                            /*
                                             * 假设runBit的值为0，
                                             * 则第一次进入这个设置的时候相当于把旧的序列的最后一次发生hash变化的节点(该节点后面可能还有hash计算后同为0的节点)设置到旧的table的第一个hash计算后为0的节点下一个节点
                                             * 并且把自己返回，然后在下次进来的时候把它自己设置为后面节点的下一个节点
                                             */
                                        ln = new Node<K,V>(ph, pk, pv, ln);
                                    else
                                            /*
                                             * 假设runBit的值不为0，
                                             * 则第一次进入这个设置的时候相当于把旧的序列的最后一次发生hash变化的节点(该节点后面可能还有hash计算后同不为0的节点)设置到旧的table的第一个hash计算后不为0的节点下一个节点
                                             * 并且把自己返回，然后在下次进来的时候把它自己设置为后面节点的下一个节点
                                             */
                                        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
                                            loTail.next = p;
                                        loTail = p;
                                        ++lc;
                                    }
                                    else {
                                        if ((p.prev = hiTail) == null)
                                            hi = p;
                                        else
                                            hiTail.next = p;
                                        hiTail = p;
                                        ++hc;
                                    }
                                }
                                /*
                                 * 在复制完树节点之后，判断该节点处构成的树还有几个节点，
                                 * 如果≤6个的话，就转回为一个链表
                                 */
                                ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) :
                                    (hc != 0) ? new TreeBin<K,V>(lo) : t;
                                hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) :
                                    (lc != 0) ? new TreeBin<K,V>(hi) : t;
                                setTabAt(nextTab, i, ln);
                                setTabAt(nextTab, i + n, hn);
                                setTabAt(tab, i, fwd);
                                advance = true;
                            }
                        }
                    }
                }
            }
        }

  • get方法

        	/*
         * 相比put方法，get就很单纯了，支持并发操作，
         * 当key为null的时候回抛出NullPointerException的异常
         * get操作通过首先计算key的hash值来确定该元素放在数组的哪个位置
         * 然后遍历该位置的所有节点
         * 如果不存在的话返回null
         */
        public V get(Object key) {
            Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
            int h = spread(key.hashCode());
            if ((tab = table) != null && (n = tab.length) > 0 &&
                (e = tabAt(tab, (n - 1) & h)) != null) {
                if ((eh = e.hash) == h) {
                    if ((ek = e.key) == key || (ek != null && key.equals(ek)))
                        return e.val;
                }
                else if (eh < 0)
                    return (p = e.find(h, key)) != null ? p.val : null;
                while ((e = e.next) != null) {
                    if (e.hash == h &&
                        ((ek = e.key) == key || (ek != null && key.equals(ek))))
                        return e.val;
                }
            }
            return null;
        }

参考文献：

  1. 一文彻底搞懂1.8ConcurrentHashMap源码
  2. ConcurrentHashMap底层实现原理(JDK1.7 & 1.8)
小望没烦恼
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ConcurrentHashMap原理分析
星空下的歌声
07-28 251
1、初始化 public ConcurrentHashMap(int initialCapacity) { if (initialCapacity < 0) throw new IllegalArgumentException(); int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ? MAXIMUM_CAPACITY
ConcurrentHashMap
mengml_smile的博客
07-21 3180
jdk1.8和jdk1.7对比 1.取消了segment(extends ReentrantLock)分段设计，直接使用Node数组来保存数据，并且采用Node数组元素作为锁(synchronized(node))来实现每一行数据进行加锁来进一步减少并发冲突的概率 2.将原本数组+单向链表的数据结构变更为了数组+单向链表+红黑树的结构 3.CAS无锁算法与synchronized保证和大量volatile修饰变量并发安全，支持并发扩容 源码解读 问题 1.ConcurrentHashMap的get方法是
面试系列Java中级：谈谈ConcurrentHashMap的原理
CancerKing的博客
11-18 529
面试系列Java中级：谈谈ConcurrentHashMap的原理
ConcurrentHashMap原理详解
最新发布
ARUNNE的博客
06-06 824
做插入操作时，首先进入乐观锁然后，在乐观锁中判断容器是否初始化，如果没初始化则初始化容器，如果已经初始化，则判断该hash位置的节点是否为空，如果为空，则通过CAS操作进行插入。如果该节点不为空，再判断容器是否在扩容中，如果在扩容，则帮助其扩容。如果没有扩容，则进行最后一步，先加锁，然后找到hash值相同的那个节点(hash冲突)循环判断这个节点上的链表，决定做覆盖操作还是插入操作。循环结束，插入完毕。
ConcurrentHashMap底层原理，通过什么来保证线程安全
qq_21277357的博客
01-30 207
当数组扩容，达到64了，并且链表的长度达到了8了，在往链表后面放数据，就会转成红黑树的结构；初始化Node数组的时候才用cas+volatile来保证线程安全;如果数组某一个位置已经放了数据，那么会在下面放一个链表；放数据的时候通过Synchronized来保证线程安全。和HashMap的区别就是增加了线程安全的操作；底层使用Node数组，默认长度16；存储结构和HashMap是一样的；
ConcurrentHashMap详解
热门推荐
唐芬奇的博客
03-28 8万+
文章目录spread()方法putVal()方法initTable()方法tryPresize()tableSizeFor()resizeStamp()transfer()总结compute()addCount() 计算成员数量sumCount()fullAddCount()资源锁sizeCtl其它节点类型forwarding节点ReservationNode节点 spread()方法 作用：用于获取槽位值 static final int spread(int h) { //h为k
java7-8中的 HashMap和ConcurrentHashMap全解析
10-23
本文将深入解析这两个类在Java 7和8版本中的实现原理、特点以及使用场景。 首先，`HashMap`是Java中最基本的非线程安全的散列映射容器。它基于哈希表实现，提供O(1)的平均时间复杂度进行插入、删除和查找操作。在...
java7-8中的 HashMap和ConcurrentHashMap全解析.pdf
10-22
本篇文章将深入解析这两种数据结构的内部实现，帮助读者理解它们的工作原理。 HashMap是Java中最常用的哈希表实现，它通过哈希函数快速定位键值对，并通过链表解决哈希冲突。在Java 7中，HashMap的内部结构主要由一...
ConcurrentHashMap源码剖析
11-27
本文将深入探讨ConcurrentHashMap的内部结构、工作原理及其在实际场景中的应用。 #### 二、结构解析 **1. 锁分段技术** ConcurrentHashMap的核心思想是将一个大哈希表分割成多个小哈希表（称为段，Segment），每...
深入解析java HashMap实现原理
09-03
综上所述，理解HashMap的实现原理对于优化Java程序性能至关重要，尤其是在处理大量数据或并发场景时。在实际应用中，应根据具体需求选择合适的数据结构，例如，如果需要线程安全，可以选择ConcurrentHashMap；如果对...
2.Java7_8+中的+HashMap+和+ConcurrentHashMap+全解析1
08-04
本文将对这两个类在Java 7和8中的实现进行深入解析，尤其是它们在并发环境下的行为和优化。 首先，我们来看Java 7的HashMap。HashMap是一个非线程安全的数据结构，适用于单线程环境。它的内部结构主要由一个数组和...
并发编程 - ConcurrentHashMap
The Secret
03-12 243
本文介绍并发编程中的ConcurrentHashMap
ConcurrentHashMap原理详解(太细了)
qq_42068856的博客
07-31 5万+
和HashMap一样，是一个存放键值对的容器。使用hash算法来获取值的地址，因此时间复杂度是O(1)。查询非常快。同时，是线程安全的HashMap。专门用于多线程环境。做插入操作时，首先进入乐观锁，然后，在乐观锁中判断容器是否初始化，如果没初始化则初始化容器，如果已经初始化，则判断该hash位置的节点是否为空，如果为空，则通过CAS操作进行插入。如果该节点不为空，再判断容器是否在扩容中，如果在扩容，则帮助其扩容。如果没有扩容，则进行最后一步，先加锁，然后找到hash。......
ConcurrentHashMap介绍
m0_46853673的博客
02-21 1082
ConcurrentHashMap介绍 在JDK1，4之前只有vector和HashTable是线程安全集合，在JDK 5之开始增加了安全的Map接口ConcurrentMap和线程安全的队列BlockingQueue
Java集合(六): ConcurrentHashMap源码剖析
mingyuli的博客
09-24 1038
1、ConcurrentHashMap简介 2、CHM数据结构 当链表节点较少时仍然是以链表存在，当链表节点较多时（大于8）会转为红黑树 3、CHM源码分析 3.1、CHM继承结构和层次关系 public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable { } 3...
基于jdk1.8之后的concurrentHashMap的node类和concurrentHashMap类的理解
gheost的博客
05-20 658
我们都知道hashmap是线程不安全的，hashtable是线程安全的，hashtable源码是通过synchronize关键字来进行修饰的， synchronize是保证线程的同步性，是通过一种锁的协议来保证共享数据的同步的。 hashtable是锁住整个结构的，如果在多线程的竞争激烈下，hashtable的效率相对很低。 在jdk1.8以前concurrentHashMap都是通过由segment数组结构和hashentry数组结构组成的，segment是concurrentHashMap里面的可重入的
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值