简谈JAVA基础--ConcurrentHashMap

ConcurrentHashMap 与 HashTable不同的是，前者的锁更加细化，而不像后者一样将没个方法都加上Synchronized关键字。

因为采用关键字来进行加锁会十分影响性能。

在jdk1.7中采用的是分段锁的概念

在jdk1.8中ConcurrentHashMap已经弃用Segment分段锁。

底层数据结构采用和HashMap相似的，数组 + 链表 + 红黑树的方式。但是多了许多并发使用的辅助类和参数。

ConcurrentHashMap参数与HashMap大部分相同。

相关变量:

table： 用来存储当前内容的数组。

nextTable：扩容操作时，用来临时存放新数组。

MOVED = -1 :Hash值为-1，标识该位置节点已经被处理过。

其中有个变量叫做sizeCtl ，这个变量根据不同场合不同用处。

1、负数用来表示正在进行初始化或者扩容操作

2、 -1  代表当前正在初始化

3、 -N  表示有N - 1 个线程正在进行扩容操作。

4、 0 代表还未进行初始化操作

5、如果是正数，代表当前数组的容量或者下次扩容的容量。( size * loadfactor  )

构造方法：

下面构造方法可以看出。在实例化时，只设置了sizeCtl参数。而实际的数组初始化是在put操作时设置的。

其中采用 initialCapacity + (initialCapacity >>> 1 ) + 1 实现了size * loadFactor的功能。

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

public ConcurrentHashMap(Map<? extends K, ? extends V> m) {
   this.sizeCtl = DEFAULT_CAPACITY;
   putAll(m);
}

public ConcurrentHashMap(int initialCapacity, float loadFactor) {
   this(initialCapacity, loadFactor, 1);
}

//concurrencyLevel参数是你预估的并发线程数
public ConcurrentHashMap(int initialCapacity,
                        float loadFactor, int concurrencyLevel) {
   if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0)
       throw new IllegalArgumentException();
   if (initialCapacity < concurrencyLevel)   // Use at least as many bins
       initialCapacity = concurrencyLevel;   // as estimated threads
   long size = (long)(1.0 + (long)initialCapacity / loadFactor);
   int cap = (size >= (long)MAXIMUM_CAPACITY) ?
       MAXIMUM_CAPACITY : tableSizeFor((int)size);
   this.sizeCtl = cap;
}

tbaleSizeFor的作用是将长度c转换为2的N次幂。写的非常巧妙。

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

初始化数组：

initTable是真正对数组进行初始化的函数。

当table为null，未进行初始化操作时，判断sizeCtl是否小于0（小于0说明已经有线程正在进行初始化操作）。

否则，无线程初始化时当前线程开始初始化操作，通过U.compareAndSwapInt(this, SIZECTL, sc, -1) 将sizeCtl置为负1

最后将sizeCtl设置为当前数组可存储键值对的阈值。

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

put操作：

这里与HashMap的操作还是比较像的。

首先key或value不能为空。

然后根据hash值来获取在table中的索引位置。如果当前位置为空，直接插入。

不同的是，如果获取到的结点为forword节点，则需要帮助另一线程进行扩容操作。

如果当前节点既非空又非forword节点，则需要判断该位置是一个树结构还是链表结构。

如果是链表结构，对该链表进行遍历，遇到key相同进行修改替换操作，否则循环完毕添加到链表的尾部。

如果是树形结构，直接按照树的操作即可。

最后，会判断链表的长度是否大于等于8，如果是，为了保证效率将链表转换为树结构。

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) {
   // 不允许key或value为空
   if (key == null || value == null) throw new NullPointerException();
   // 获取hash值
   int hash = spread(key.hashCode());
   // 链表的长度
   int binCount = 0;
   // 死循环，直到添加成功。
  // 因为是多线程操作，没有使用锁，unsafe不是原子的，所以采用for循环
   for (Node<K,V>[] tab = table;;) {
      // f为节点，n是数组的长度， i是数组索引下标，fn是索引处节点的hash值
       Node<K,V> f; int n, i, fh;
       // 如果tab为null，进行初始化操作
       if (tab == null || (n = tab.length) == 0)
           tab = initTable();
       // 根据hash值获取在table中的位置节点。如果为空，直接插入
      // 如果多个线程同时插入，那么只有一个会成功，其他的失败，继续循环
       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
       }
       // 否则判断是否是forword节点，如果是帮助进行扩容操作。
      // ForwordingNode对象在 hash散列的时候用，原来的一个节点会重新散列到下个表，原来表的节点的hash就成为了 moved
       else if ((fh = f.hash) == MOVED)
           tab = helpTransfer(tab, f);
       // 当前节点非空并且不是forword节点
       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;
                       }
                   }
               }
           }
           // 如果链表长度 >= 8，直接转换为一个红黑树
           if (binCount != 0) {
               if (binCount >= TREEIFY_THRESHOLD)
                   treeifyBin(tab, i);
               if (oldVal != null)
                   return oldVal;
               break;
           }
       }
   }
  // 当前数量 +1
   addCount(1L, binCount);
   return null;
}

辅助扩容操作：

nextTable是用来扩容时的临时数组。

当扩容时，nextTable是肯定存在，这里获取到nextTable,然后调用扩容操作。并且把sizeCtl + 1;代表有sizeCtl -1 个线程在进行扩容操作。

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;
           if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {
               transfer(tab, nextTab);
               break;
           }
       }
       return nextTab;
   }
   return table;
}

链表转换树结构:

首先判断当前tab的长度是否小于64

如果是，直接进行扩容一倍返回。

否则创建一个TreeBin封装所有的节Node结点。

将原链表节点替换为新的树节点。

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)
           tryPresize(n << 1);
       else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {
           synchronized (b) {
               if (tabAt(tab, index) == b) {
                   TreeNode<K,V> hd = null, tl = null;
                   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);
                       if ((p.prev = tl) == null)
                           hd = p;
                       else
                           tl.next = p;
                       tl = p;
                   }
                   setTabAt(tab, index, new TreeBin<K,V>(hd));
               }
           }
       }
   }
}

扩容操作发生条件：

1、在添加新的内容后执行addCount() ，检查是否扩容操作。

2、在链表转换树结构操作时，会先判断是否需要扩容操作。

扩容操作步骤：

扩容操作与HashMap相类似，但是由于支持多并发情况，为了提高效率，采用了多线程同时扩容的操作。

所以从原数组copy到新数组的操作更加复杂。

1、首先创建一个nextTable数组。容量为原数组的两倍。

2、初始化ForwardingNode 节点，包含nextTable的引用。并且标识该节点已经被处理过。

3、循环每个节点中的链表元素。advace为true代表该节点已经被处理过。

4、初始化i和bound，i指当前处理的节点位置，bound为需要处理的节点边界。

5、如果原数组大小默认为16，则先处理位置在15的节点。

6、如果该位置没有节点，则通过  advance = casTabAt(tab, i, null, fwd); CAS插入Forworad节点。其他线程看到后知道该位置已经处理过了。

7、当其他线程处理到forword节点时，得到该节点hash值为MOVED，直接跳过。这里是保证多线程同时扩容的核心。

8、当处理到的节点是一个链表结构，会将链表的所有元素分为两部分，分别为Hash值第N(n为数组长度)位为0和1的节点。

9、然后将两部分链表插入到n新数组nextTable的i 和 i+n位置。原数组i位置置为forword。

10、如果该节点是一个红黑树结构，则构造树节点lo和hi，遍历红黑树中的节点，同样根据hash&n算法，把节点分为两类，分别插入到lo和hi为头的链表中，根据lo和hi链表中的元素个数分别生成ln和hn节点，其中ln节点的生成逻辑如下：

（1）如果lo链表的元素个数小于等于UNTREEIFY_THRESHOLD，默认为6，则通过untreeify方法把树节点链表转化成普通节点链表；

（2）否则判断hi链表中的元素个数是否等于0：如果等于0，表示lo链表中包含了所有原始节点，则设置原始红黑树给ln，否则根据lo链表重新构造红黑树。

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
       // 初始化nextTable临时扩容数组，长度为原数组的两倍 
            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;
        }
       // 实例化ForwardingNode节点，包含nextTable引用。
        int nextn = nextTab.length;
        ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
       // 标识该节点被处理过
        boolean advance = true;
       // 标识是否完成数据的copy
        boolean finishing = false; // to ensure sweep before committing nextTab
       // 循环copy所有的节点到新数组nextTable中
        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
                }
            }
           // 如果该位置节点为空，插入forword节点，标识该位置被处理过
            else if ((f = tabAt(tab, i)) == null)
                advance = casTabAt(tab, i, null, fwd);
           // 如果该位置节点Hash为-1，直接跳过。
            else if ((fh = f.hash) == MOVED)
                advance = true; // already processed
            else {
           // 否则处理节点，并且用synchronized修饰，保证线程安全。
                synchronized (f) {
                    if (tabAt(tab, i) == f) {
                        Node<K,V> ln, hn;
                       // 处理链表，生成反向链表插入到i和i+n位置
                        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
                                        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 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;
                        }
                    }
                }
            }
        }
    }

参考资料：

深入浅出ConcurrentHashMap（1.8）

ConcurrentHashMap的红黑树实现分析

深入分析ConcurrentHashMap1.8的扩容实现 

http://www.cnblogs.com/study-everyday/p/6430462.html