9.1 Hashtable与ConcurrentHashMap详解

9.1 Hashtable与ConcurrentHashMap详解

1.0 Hashtable详解

​ Hashtable 和HashMap用法是和底层的结构都是数组+链表+红黑树，都是key-value键值对数据的存储，最大的区别就是HashMap线程不安全，Hashtable 线程安全。HashMap当什么时候会发生线程不安全呢？当两个线程同时新增在数组上同一位置的数据时(同一链表数据)，两线程同时操作数据可能被冲掉。

1.1 Hashtable线程安全特性

​ 通常让解决线程安全的方式就是 synchronized 和Lock ,Hashtable就是采用的是在方法前面添加synchronized，在put，remove，clone，get 等相关方法前都添加的锁。如下

public synchronized V put(K key, V value) 
public synchronized V remove(Object key)
public synchronized Object clone()
public synchronized V get(Object key)

Hashtable实现线程安全方式比较简单，但是效率低。ConcurrentHashMap的效率比较高。

2.ConcurrentHashMap

2.1 1.7线程安全的逻辑

首先，我们来看JDK 1.7中ConcurrentHashMap的底层结构，它基本延续了HashMap的设计，采用的是数组 加 链表的形式。和HashMap不同的是，ConcurrentHashMap中的数组设计 分为大数组Segment和小数组HashEntry ；大数组Segment理解为数据库，每个数据库(Segment)中有很多张表(HashEntry),每个HashEntry中有很多条数据，这些数据是用链表连接的。

​ Segment本身是基于ReentrantLock重入锁实现的加锁和释放锁的操作，这样就能保证多个线程同时访问ConcurrentHashMap时，同一时间只能有一个线程能够操作相应的节点，这样就保证了ConcurrentHashMap的线程安全。 ConcurrentHashMap的线程安全是建立在Segment加锁的基础上的，所以，我们称它为分段锁或者片段锁。

2.2 1.8线程安全逻辑

重要成员变量
ConcurrentHashMap拥有出色的性能，在真正掌握内部结构时，先要掌握比较重要的成员：
1)LOAD_FACTOR 载因子，默认75%，当table使用率达到75%时，为减少table的hash碰撞，tabel长度将扩容一倍。负载因子计算:元素总个数%table.lengh ;
2)TREEIFY_THRESHOLD:默认8当链表长度达到8时，将结构转变为红黑树。
3)UNTREEIFY_THRESHOLD: 默认6.红里树转变为链表的阈值。

4)MIN_TRANSFER_STRIDE:默认16,table扩容时，每个线程最少迁移table的槽位个数。 MOVED:值为-1,当5)Node.hash为MOVED时，代表着table正在扩容 TREEBIN.置为-2.代表此元素后接红黑树。
6)nextTable:table迁移过程临时变量，在迁移过程中将元素全部迁移到nextTable上。
7) sizeCt:用来标志table初始化和扩容的，不同的取值代表着不同的含义:
7.1)0:table还没有被初始化
7.2)-1:table正在初始化
7.3)小于-1:实际值为resizeStamp(n)<<RESIZESTAMP_ SHIFT+2，表明table正在扩容
7.4)大于0:初始化完成后，代表table最大存放元素的个数，默认为0.75*n
8)transferlndex:table容量从n扩到2n时，是从索引n->1的元素开始迁移，transferlndex代表当前已经迁移的元素下标
9)ForwardinaNode:一个特殊的Node节点，其hashcode=MOVED，代表着此时table正在做扩容操作，扩容期间，若table某个元素为null那么该元素设置为ForwardingNode,当下个线程向这个元素插入数据时，检查hashcode=MOVED.就会帮着扩容。
ConcurrentHashMap由三部分构成，table+链表+红黑树，其中table是一个数组，既然是数组，必须要在使用时确定数组的大小，当table存放的元素过多时，,就需要扩容，以减少碰撞发生次数，本文就讲解扩容的过程。扩容检查主要发生在插入元素(putVal0)的过程:

• 一个线程插完元素后，检查table使用率若超过闻值，调用transfer进行扩容
• 个线程插入数时发table对应元素的hash=MOVED 那么调用helpTransfer协助扩容

final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) {
        Node<K,V>[] nextTab; int sc;
        if (tab != null && (f instanceof ForwardingNode) &&
            (nextTab = ((ForwardingNode<K,V>)f).nextTable) != null) {
            int rs = resizeStamp(tab.length);
            while (nextTab == nextTable && table == tab &&
                   (sc = sizeCtl) < 0) { // 说明还在扩容
                //判断是否标志发生变化||扩容结束
                if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
                    //达到最大的帮主线程||判断扩容转移下标是否在调整(扩容结束)
                    sc == rs + MAX_RESIZERS || transferIndex <= 0)
                    break;
                //将SizeCtrl+1，表示增加一个线程帮做扩容
                if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {
                    transfer(tab, nextTab);
                    break;
                }
            }
            return nextTab;
        }
        return table;
    }

上面helpTransfer写作扩容源码主要事情如下：
1)检查是否扩容完毕；
2)对SizeCtrl=SizeCtrl+1,然后调用transfer真正扩容。

transfer源码

整体步骤就是新建一个nextTab,size是之前的2倍，将table上的非空元素迁移到nextTab上面去。

    private final void transfer(ConcurrentHashMap.Node<K,V>[] tab, ConcurrentHashMap.Node<K,V>[] nextTab) {
        int n = tab.length, stride;
        if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
            // subdivide range 每个线程最少迁移16个槽位
            stride = MIN_TRANSFER_STRIDE;
        // initiating 开始初始化新的nextTab
        if (nextTab == null) {
            try {
                @SuppressWarnings("unchecked")
                ConcurrentHashMap.Node<K,V>[] nt = (ConcurrentHashMap.Node<K,V>[])new ConcurrentHashMap.Node<?,?>[n << 1];//扩容2倍
                nextTab = nt;
            } catch (Throwable ex) {      // try to cope with OOME
                sizeCtl = Integer.MAX_VALUE;
                return;
            }
            nextTable = nextTab;
            transferIndex = n;//更新转移下标
        }
        int nextn = nextTab.length;
        ConcurrentHashMap.ForwardingNode<K,V> fwd = new ConcurrentHashMap.ForwardingNode<K,V>(nextTab);
        //是否能够向前推进到下一个周期
        boolean advance = true;
        // to ensure sweep before committing nextTab 完成状态，如果是，则结束此方法
        boolean finishing = false;
        for (int i = 0, bound = 0;;) {
            ConcurrentHashMap.Node<K,V> f; int fh;
            while (advance) {//取下一周期
                //本线程处理的区间为[bound,i]，范围还没处理完成，那么久继续处理
                int nextIndex, nextBound;
                if (--i >= bound || finishing)
                    advance = false;
                //目前处理到这里(从大到小，下线)，开始找新的一轮的区间
                else if ((nextIndex = transferIndex) <= 0) {
                    i = -1;
                    advance = false;
                }
                //这个条件改变的是TRANSFERINDEX的值，从16变成1
                else if (U.compareAndSwapInt
                        (this, TRANSFERINDEX, nextIndex,
                                nextBound = (nextIndex > stride ?
                                        nextIndex - stride : 0))) {
                    //nextBound 是这次迁移任务的边界，注意是从后向前
                    bound = nextBound;//一块区间最小链表的下标
                    i = nextIndex - 1;//能够处理的最大链表的下标
                    advance = false;
                }
            }
            if (i < 0 || i >= n || i + n >= nextn) {
                int sc;
                if (finishing) {
                    nextTable = null;
                    //直接把以前的table丢弃了，上面的MOVE等标志全部丢弃，使用新的
                    table = nextTab;
                    sizeCtl = (n << 1) - (n >>> 1);//扩大2n-0.5n=1.50n,更新新的容量阈值
                    return;
                }
                //表示当前线程迁移完成了
                if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
                    //注意此时sc的值不等于sizeCtl，上一步sizeCtl=sizeCtl-1了。这两个对象还是分割的
                    if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
                        return;
                    finishing = advance = true;
                    i = n; // recheck before commit
                }
            }
            //如果对应位置为null,则将ForwardingNode 放在对应的地方
            else if ((f = tabAt(tab, i)) == null)
                advance = casTabAt(tab, i, null, fwd);
            //别的线程已经在处理了，再推进一个下标
            else if ((fh = f.hash) == MOVED)
                // already processed 推动下一个周期，仍然会检查i与bound是否结束
                advance = true;
            else {//说明位置上有值了
                //需要加锁，防止在向里面放值，在放数据时，也会锁住。比如整个table正在迁移，还没有迁移到这个元素，另外一个线程在操作
                synchronized (f) {
                    if (tabAt(tab, i) == f) {//判断i下标和f是否相同
                        ConcurrentHashMap.Node<K,V> ln, hn;
                        if (fh >= 0) {
                            int runBit = fh & n;//高位链表和低位链表
                            ConcurrentHashMap.Node<K,V> lastRun = f;
                            for (ConcurrentHashMap.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 (ConcurrentHashMap.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 ConcurrentHashMap.Node<K,V>(ph, pk, pv, ln);
                                else
                                    hn = new ConcurrentHashMap.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 ConcurrentHashMap.TreeBin) {
                            ConcurrentHashMap.TreeBin<K,V> t = (ConcurrentHashMap.TreeBin<K,V>)f;
                            ConcurrentHashMap.TreeNode<K,V> lo = null, loTail = null;
                            ConcurrentHashMap.TreeNode<K,V> hi = null, hiTail = null;
                            int lc = 0, hc = 0;
                            for (ConcurrentHashMap.Node<K,V> e = t.first; e != null; e = e.next) {
                                int h = e.hash;
                                ConcurrentHashMap.TreeNode<K,V> p = new ConcurrentHashMap.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;
                                }
                            }
                            ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) :
                                    (hc != 0) ? new ConcurrentHashMap.TreeBin<K,V>(lo) : t;
                            hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) :
                                    (lc != 0) ? new ConcurrentHashMap.TreeBin<K,V>(hi) : t;
                            setTabAt(nextTab, i, ln);
                            setTabAt(nextTab, i + n, hn);
                            setTabAt(tab, i, fwd);
                            advance = true;
                        }
                    }
                }
            }
        }
    }

其中有两个变量需要了解下:
1)advance:表示是否可以向下一个轮元素进行迁移。
2)finishing:table所有元素是否迁移完成。
大致做了如下事情
1>确定线程每轮许移元素的个数stride.比如讲来一个线程，确定扩容table下标为(ab]之间元素，下一个线程扩容(bc]，这里对b-a或者c-b也是中最小值16限制的，也就是说每个线程最少扩容连续16个table的元素，而标志当前许移的下标保存在transferindex里面.
2>检查nextTab是否完成初始化，若没有的话，说明是第一个迁移的线程，先初始化nextTabsize是之前table的2倍。
3>进入while循环查找本轮迁移的table下标元素区间，保存在(boundi]中，注意这里是半开半闭区间。
4>从i->bound开始遍历table中每个元素，这里是从大到小遍历的:
1.若该元素为空，则向该元素标写入ForwardinaNode，然后检查下一个元素，当别的线程向这个元素插入数据时，根据这个标志符知道了table正在被别的线程迁移，在 putVal中就会调用helpTransfer帮着迁移。
2.若该元素的hash=MOVED,代表次table正在处干迁移之中，跳过，按道理不会跑着这里的。
3.否则说明该元素跟着的是一个链表或者是个红里树结构，若hash>0，则说明是个链表，若f instanceof TreeBin,则说明是个红里树结构。
5>链表迁移原理如下;遍历链表每个节点。若节点的f，hashsn== 0成立，则将节点放在i，否则，则将节点放在n+i上面.
迁移前，对该元素进行加锁。遍历链表时，这里使用lastRun变量，保留的是上次hash的值，假如整个链表全部节点f.hash&n==0，那么第二次遍历，只要找到lastRun的值，那么认为之后的节点都是相同值。减少了不必要的fhash&n取值。遍历完所有的节点后，此时形成了两条链表，In存放的是f.hash&n=0的节点，hn存放的是非0的节点，然后将In存放在nextTable第i元素的位置，n+i存放在n+i的位置 。