ConcurrentHashMap详解

 基本特点

• 和HashMap功能基本一致，主要是为了解决HashMap线程不安全问题；
• java7中的基本设计理念就是切分成多个Segment块，默认是16个，也就是说并发度是16，可以初始化时显式指定，后期不能修改，每个Segment里面可以近似看成一个HashMap，每个Segment块都有自己独立的ReentrantLock锁，所以并发操作时每个Segment互不影响；java8中将Segment块换成了Node，每个Node有自己的锁，即每个Node都有自己的并发度；
• 不允许空值和空键，否则会抛出异常；

 核心方法put()、get()解读

结合源码来看put()动作做了哪些事情（源码取自jdk1.8）:

• key-value的检验，不允许为空，否则抛出异常；
• 用while(true)无限重试put动作，直到put成功；
• 如果数组没有初始化过则先进行初始化工作；
• 如果数组中该hashcode对应位置不存在元素，则将该元素以CAS方式放入，对应的casTabAt()方法；
• 如果数组中存在元素，用synchronized块保证同步操作，循环判断链表中是否存在该value，存在则返回oldValue，不存在则插入链表末端，put成功跳出循环；
• 如果是红黑树，则将元素放入红黑树节点中；
• put完成后根据链表长度是否大于8且数组长度是否大于64来判断是否将链表转换成红黑树；
• 返回oldValue值；

    public V put(K var1, V var2) {
        return this.putVal(var1, var2, false);
    }

    final V putVal(K var1, V var2, boolean var3) {
        if (var1 != null && var2 != null) {
            int var4 = spread(var1.hashCode());
            int var5 = 0;
            ConcurrentHashMap.Node[] var6 = this.table;

            while(true) {
                int var8;
                while(var6 == null || (var8 = var6.length) == 0) {
                    var6 = this.initTable();
                }

                ConcurrentHashMap.Node var7;
                int var9;
                if ((var7 = tabAt(var6, var9 = var8 - 1 & var4)) == null) {
                    if (casTabAt(var6, var9, (ConcurrentHashMap.Node)null, new ConcurrentHashMap.Node(var4, var1, var2, (ConcurrentHashMap.Node)null))) {
                        break;
                    }
                } else {
                    int var10 = var7.hash;
                    if (var7.hash == -1) {
                        var6 = this.helpTransfer(var6, var7);
                    } else {
                        Object var11 = null;
                        synchronized(var7) {
                            if (tabAt(var6, var9) == var7) {
                                if (var10 < 0) {
                                    if (var7 instanceof ConcurrentHashMap.TreeBin) {
                                        var5 = 2;
                                        ConcurrentHashMap.TreeNode var18;
                                        if ((var18 = ((ConcurrentHashMap.TreeBin)var7).putTreeVal(var4, var1, var2)) != null) {
                                            var11 = var18.val;
                                            if (!var3) {
                                                var18.val = var2;
                                            }
                                        }
                                    }
                                } else {
                                    var5 = 1;
                                    ConcurrentHashMap.Node var13 = var7;

                                    while(true) {
                                        if (var13.hash == var4) {
                                            Object var14 = var13.key;
                                            if (var13.key == var1 || var14 != null && var1.equals(var14)) {
                                                var11 = var13.val;
                                                if (!var3) {
                                                    var13.val = var2;
                                                }
                                                break;
                                            }
                                        }

                                        ConcurrentHashMap.Node var15 = var13;
                                        if ((var13 = var13.next) == null) {
                                            var15.next = new ConcurrentHashMap.Node(var4, var1, var2, (ConcurrentHashMap.Node)null);
                                            break;
                                        }

                                        ++var5;
                                    }
                                }
                            }
                        }

                        if (var5 != 0) {
                            if (var5 >= 8) {
                                this.treeifyBin(var6, var9);
                            }

                            if (var11 != null) {
                                return var11;
                            }
                            break;
                        }
                    }
                }
            }

            this.addCount(1L, var5);
            return null;
        } else {
            throw new NullPointerException();
        }
    }

再看get()动作做了哪些事情：

• 判断数组是否为空，为空直接返回null；
• 根据hash值查找，如果hash值相等且key也相等，则直接返回value值；
• 如果key的hash值小于0，说明是红黑树，则进入红黑树查找到该节点值；
• 否则进入循环链表读取该value值并返回；

    public V get(Object var1) {
        int var8 = spread(var1.hashCode());
        ConcurrentHashMap.Node[] var2 = this.table;
        ConcurrentHashMap.Node var3;
        int var5;
        if (this.table != null && (var5 = var2.length) > 0 && (var3 = tabAt(var2, var5 - 1 & var8)) != null) {
            int var6 = var3.hash;
            Object var7;
            if (var3.hash == var8) {
                var7 = var3.key;
                if (var3.key == var1 || var7 != null && var1.equals(var7)) {
                    return var3.val;
                }
            } else if (var6 < 0) {
                ConcurrentHashMap.Node var4;
                return (var4 = var3.find(var8, var1)) != null ? var4.val : null;
            }
            while((var3 = var3.next) != null) {
                if (var3.hash == var8) {
                    var7 = var3.key;
                    if (var3.key == var1 || var7 != null && var1.equals(var7)) {
                        return var3.val;
                    }
                }
            }
        }
        return null;
    }

 jdk1.7升级到1.8，ConcurrentHashMap的变化

• 锁方面：由分段锁（Segment继承自ReentrantLock）升级为CAS+synchronized实现；
• 数据结构层面：将Segment变为了Node，每个Node独立，原来默认的并发度16，变成了每个Node都独立，提高了并发度；
• hash冲突：1.7中发生hash冲突采用链表存储，1.8中先使用链表存储，后面满足条件后会转换为红黑树来优化查询；
• 查询复杂度：1.7中链表查询复杂度为O(N)，1.8中红黑树优化为O(logN))；

 链表长度为什么超过8要转为红黑树？

• 默认的是链表结构，并不是一开始就是红黑树结构，因为链表比红黑数占用的空间较少；
• hash冲突导致链表长度真正达到8的概率极小，约为一千万分之一，同时也考虑到红黑树查询比链表快；