jdk8之ConcurrentHashMap源码解析

1. java.util.concurrent 这个包下面的 类都很经典。
2. ConcurrentHashMap 这个类是java中讨论最多的，也是争论最多的类了。很多人对这个类很好奇。
3. 作为并发集合，大家比较关心 读写，锁，与 map的散列。
4. 读写如何的锁
5. get操作 下载
   Java代码  

   1. public V get(Object key) {  
   2.     Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;  
   3.     int h = spread(key.hashCode());  
   4.     if ((tab = table) != null && (n = tab.length) > 0 &&  
   5.         (e = tabAt(tab, (n - 1) & h)) != null) {  
   6.         if ((eh = e.hash) == h) {  
   7.             if ((ek = e.key) == key || (ek != null && key.equals(ek)))  
   8.                 return e.val;  
   9.         }  
   10.         else if (eh < 0)   
   11.             // TreeBin 操作  
   12.             return (p = e.find(h, key)) != null ? p.val : null;  
   13.         while ((e = e.next) != null) {  
   14.             if (e.hash == h &&  
   15.                 ((ek = e.key) == key || (ek != null && key.equals(ek))))  
   16.                 return e.val;  
   17.         }  
   18.     }  
   19.     return null;  
   20. }  
    明显是没有上锁的。包括所有的读操作。都是不上锁的。
6. put操作（remove等修改操作）
7. 所有读操作是这样一个模式，如果hash桶中坐标没有数据。就使用CAS 操作。如果有数据。就使用synchronized关键字。比起jdk1.7,1.6使用读写锁，代码比较简洁，同样使用cas操作比 读写锁的性呢过开销底得太多了。但是程序设计变得十分复杂，请下添加的代码下载
8. Java代码  

   1. final V putVal(K key, V value, boolean onlyIfAbsent) {  
   2.         if (key == null || value == null) throw new NullPointerException();  
   3.         int hash = spread(key.hashCode());  
   4.         int binCount = 0;  
   5.         //为什么要这个循序，大家会很疑惑  
   6.         //其实很简单，因为多线程操作，然后没有使用锁，使用 unsafe，多个unsafe不是原子性的，在多线程的情况下，会出现问题。所以使用for来解决这个问题  
   7.         for (Node<K,V>[] tab = table;;) {  
   8.             // f 是节点，n是数组长度，i是hash与数组长度的数组下标，fh是在数组下标已经坐在的节点的hash值  
   9.             Node<K,V> f; int n, i, fh;  
   10.             if (tab == null || (n = tab.length) == 0)  
   11.                 tab = initTable();//延迟初始化 table  
   12.             //通过unsafe 判断 下标是否有 节点  
   13.             else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {  
   14.                 //如果不存在。就创建一个节点 通过 unsafe加入到数组中，所以读是不加锁的  
   15.                 //注意：如果在多个线程同时加入 hash后同一下标的node，那么只有一个会成功，其他失败。失败的就会在再次循序。  
   16.                 //这是循环解决的问题之一  
   17.                 if (casTabAt(tab, i, null,  
   18.                              new Node<K,V>(hash, key, value, null)))  
   19.                     break;                   // no lock when adding to empty bin  
   20.             }  
   21.             //大家很奇怪这个 if是干什么用额，去了解ForwardingNode这个对象  
   22.             //这个对象在 hash散列的时候用，原来的一个节点会重新散列到 下个表，原来表的节点的hash就成为了 moved  
   23.             else if ((fh = f.hash) == MOVED)  
   24.                 tab = helpTransfer(tab, f);  
   25.             else {  
   26.                 V oldVal = null;  
   27.                 //如果节点存在，就需要添加链了。  
   28.                 //添加链的时候 就上锁 这个节点，那么所有在这个节点的更新操作都会上锁  
   29.                 //这里上锁，比双桶的开销小多了。如果设计好，可以说几乎忽略不计。  
   30.                 synchronized (f) {  
   31.                     if (tabAt(tab, i) == f) {  
   32.                         if (fh >= 0) {  
   33.                             //添加链表  
   34.                             binCount = 1;  
   35.                             for (Node<K,V> e = f;; ++binCount) {  
   36.                                 K ek;  
   37.                                 if (e.hash == hash &&  
   38.                                     ((ek = e.key) == key ||  
   39.                                      (ek != null && key.equals(ek)))) {  
   40.                                     oldVal = e.val;  
   41.                                     if (!onlyIfAbsent)  
   42.                                         e.val = value;  
   43.                                     break;  
   44.                                 }  
   45.                                 Node<K,V> pred = e;  
   46.                                 if ((e = e.next) == null) {  
   47.                                     pred.next = new Node<K,V>(hash, key,  
   48.                                                               value, null);  
   49.                                     break;  
   50.                                 }  
   51.                             }  
   52.                         }  
   53.                         //添加 在tree下添加节点  
   54.                         else if (f instanceof TreeBin) {  
   55.                             Node<K,V> p;  
   56.                             binCount = 2;  
   57.                             if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,  
   58.                                                            value)) != null) {  
   59.                                 oldVal = p.val;  
   60.                                 if (!onlyIfAbsent)  
   61.                                     p.val = value;  
   62.                             }  
   63.                         }  
   64.                     }  
   65.                 }  
   66.                 //java8，明确的改革  
   67.                 if (binCount != 0) {  
   68.                     //binCount是链表的操作次数，操作多少次。表示链表有多长。当链表大于等于8的时候，链表会变成 tree  
   69.                     if (binCount >= TREEIFY_THRESHOLD)  
   70.                         treeifyBin(tab, i);  
   71.                     if (oldVal != null)  
   72.                         return oldVal;  
   73.                     break;  
   74.                 }  
   75.             }  
   76.         }  
   77.         addCount(1L, binCount);  
   78.         return null;  
   79.   
   80. }  
    
9. 这里是大家最关心的要点，重新散列，也就是重新hash 下载
   Java代码  

   1.     final V putVal(K key, V value, boolean onlyIfAbsent) {  
   2.         if (key == null || value == null) throw new NullPointerException();  
   3.         int hash = spread(key.hashCode());  
   4.         int binCount = 0;  
   5.         //为什么要这个循序，大家会很疑惑  
   6.         //其实很简单，因为多线程操作，然后没有使用锁，使用 unsafe，多个unsafe不是原子性的，在多线程的情况下，会出现问题。所以使用for来解决这个问题  
   7.         for (Node<K,V>[] tab = table;;) {  
   8.             // f 是节点，n是数组长度，i是hash与数组长度的数组下标，fh是在数组下标已经坐在的节点的hash值  
   9.             Node<K,V> f; int n, i, fh;  
   10.             if (tab == null || (n = tab.length) == 0)  
   11.                 tab = initTable();//延迟初始化 table  
   12.             //通过unsafe 判断 下标是否有 节点  
   13.             else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {  
   14.                 //如果不存在。就创建一个节点 通过 unsafe加入到数组中，所以读是不加锁的  
   15.                 //注意：如果在多个线程同时加入 hash后同一下标的node，那么只有一个会成功，其他失败。失败的就会在再次循序。  
   16.                 //这是循环解决的问题之一  
   17.                 if (casTabAt(tab, i, null,  
   18.                              new Node<K,V>(hash, key, value, null)))  
   19.                     break;                   // no lock when adding to empty bin  
   20.             }  
   21.             //大家很奇怪这个 if是干什么用额，去了解ForwardingNode这个对象  
   22.             //这个对象在 hash散列的时候用，原来的一个节点会重新散列到 下个表，原来表的节点的hash就成为了 moved  
   23.             else if ((fh = f.hash) == MOVED)  
   24.                 tab = helpTransfer(tab, f);  
   25.             else {  
   26.                 V oldVal = null;  
   27.                 //如果节点存在，就需要添加链了。  
   28.                 //添加链的时候 就上锁 这个节点，那么所有在这个节点的更新操作都会上锁  
   29.                 //这里上锁，比双桶的开销小多了。如果设计好，可以说几乎忽略不计。  
   30.                 synchronized (f) {  
   31.                     if (tabAt(tab, i) == f) {  
   32.                         if (fh >= 0) {  
   33.                             //添加链表  
   34.                             binCount = 1;  
   35.                             for (Node<K,V> e = f;; ++binCount) {  
   36.                                 K ek;  
   37.                                 if (e.hash == hash &&  
   38.                                     ((ek = e.key) == key ||  
   39.                                      (ek != null && key.equals(ek)))) {  
   40.                                     oldVal = e.val;  
   41.                                     if (!onlyIfAbsent)  
   42.                                         e.val = value;  
   43.                                     break;  
   44.                                 }  
   45.                                 Node<K,V> pred = e;  
   46.                                 if ((e = e.next) == null) {  
   47.                                     pred.next = new Node<K,V>(hash, key,  
   48.                                                               value, null);  
   49.                                     break;  
   50.                                 }  
   51.                             }  
   52.                         }  
   53.                         //添加 在tree下添加节点  
   54.                         else if (f instanceof TreeBin) {  
   55.                             Node<K,V> p;  
   56.                             binCount = 2;  
   57.                             if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,  
   58.                                                            value)) != null) {  
   59.                                 oldVal = p.val;  
   60.                                 if (!onlyIfAbsent)  
   61.                                     p.val = value;  
   62.                             }  
   63.                         }  
   64.                     }  
   65.                 }  
   66.                 //java8，明确的改革  
   67.                 if (binCount != 0) {  
   68.                     //binCount是链表的操作次数，操作多少次。表示链表有多长。当链表大于等于8的时候，链表会变成 tree  
   69.                     if (binCount >= TREEIFY_THRESHOLD)  
   70.                         treeifyBin(tab, i);  
   71.                     if (oldVal != null)  
   72.                         return oldVal;  
   73.                     break;  
   74.                 }  
   75.             }  
   76.         }  
   77.         addCount(1L, binCount);  
   78.         return null;  
   79.   
   80. }  
   81.   
   82.   
   83.  private final void addCount(long x, int check) {  
   84.         CounterCell[] as; long b, s;  
   85.         //这个判断的目的是 解决 unsafu的死循环问题  
   86.         if ((as = counterCells) != null ||  
   87.             !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {  
   88.             CounterCell a; long v; int m;  
   89.             boolean uncontended = true;  
   90.             if (as == null || (m = as.length - 1) < 0 ||  
   91.                 (a = as[ThreadLocalRandom.getProbe() & m]) == null ||  
   92.                 !(uncontended =  
   93.                   U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {  
   94.                 fullAddCount(x, uncontended);  
   95.                 return;  
   96.             }  
   97.             if (check <= 1)  
   98.                 return;  
   99.             s = sumCount();  
   100.         }  
   101.         // 有一个问题 ，只有添加操作是 大于0的，那么 没有hash收缩功能  
   102.         if (check >= 0) {  
   103.             Node<K,V>[] tab, nt; int n, sc;  
   104.             //我靠，这里又有一个循序，是解决什么问题了？  
   105.             //sc也就是 sizeCtl 等于 -1的情况只有，table初始化与序列化的时候。  
   106.             //这个循环是保证 序列化之后，还可以加入数据，目测是这样，不敢保证。  
   107.             while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&  
   108.                    (n = tab.length) < MAXIMUM_CAPACITY) {  
   109.                 int rs = resizeStamp(n);  
   110.                 // 这个if 基本可以忽略  
   111.                 if (sc < 0) {  
   112.                     if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||  
   113.                         sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||  
   114.                         transferIndex <= 0)  
   115.                         break;  
   116.                     if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))  
   117.                         transfer(tab, nt);  
   118.                 }  
   119.                 //把扩容的值 替换原先的值  
   120.                 //并发情况下，多个线程都到达这步，只有一个操作会成功，成功之后其他的线程都会进不来这个。  
   121.                 else if (U.compareAndSwapInt(this, SIZECTL, sc,  
   122.                                              (rs << RESIZE_STAMP_SHIFT) + 2))  
   123.                     transfer(tab, null);  
   124.                 s = sumCount();  
   125.             }  
   126.         }  
   127.     }  
   128.   
   129.   
   130. private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {  
   131.         int n = tab.length, stride;  
   132.         if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)  
   133.             stride = MIN_TRANSFER_STRIDE; // subdivide range  
   134.         if (nextTab == null) {            // initiating  
   135.             try {  
   136.                 @SuppressWarnings("unchecked")  
   137.                 Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];  
   138.                 nextTab = nt;  
   139.             } catch (Throwable ex) {      // try to cope with OOME  
   140.                 sizeCtl = Integer.MAX_VALUE;  
   141.                 return;  
   142.             }  
   143.             nextTable = nextTab;  
   144.             transferIndex = n;  
   145.         }  
   146.         int nextn = nextTab.length;  
   147.         // good 这个对象，的设计。让散列操不会堵塞  
   148.         ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);  
   149.         boolean advance = true; // 只要过了 第一个 while 基本所有操作都会 advance = true;,每次循环都要进入 while 那么 i 这个值才会改变  
   150.         boolean finishing = false; // to ensure sweep before committing nextTab  
   151.         for (int i = 0, bound = 0;;) {  
   152.             Node<K,V> f; int fh;  
   153.             //这个 while 真心不怎么明白  
   154.             //唯一能解释的是，防止散列完成，才知道多线程操作问题,快速知道多线程问题  
   155.             while (advance) {  
   156.                 int nextIndex, nextBound;  
   157.                 if (--i >= bound || finishing)  
   158.                     advance = false;  
   159.                 //这个判断只可能进来一次，  
   160.                 else if ((nextIndex = transferIndex) <= 0) {  
   161.                     i = -1;  
   162.                     advance = false;  
   163.                 }  
   164.                 //比如 n 等于 128，stride 为 128 >>>3 /8 =2,  
   165.                 //i = 128,bound -126,那么每两次就会在进来一次，那么就会知道，(nextIndex = transferIndex) 这操作就会知道多线程在操作  
   166.                 else if (U.compareAndSwapInt  
   167.                          (this, TRANSFERINDEX, nextIndex,  
   168.                           nextBound = (nextIndex > stride ?  
   169.                                        nextIndex - stride : 0))) {  
   170.                     bound = nextBound;  
   171.                     i = nextIndex - 1;  
   172.                     advance = false;  
   173.                 }  
   174.             }  
   175.             //  
   176.             // 那个操作会让 i 大于等于 n ,这个真想不到  
   177.             // i + n 也大于等于不了 nextn 啊，  
   178.             //只有一个可能，在强并发下，有两个线程都进入了。进行操作了。没错  
   179.             //  
   180.             if (i < 0 || i >= n || i + n >= nextn) {  
   181.                 int sc;  
   182.                 if (finishing) {  
   183.                     nextTable = null;  
   184.                     table = nextTab;  
   185.                     sizeCtl = (n << 1) - (n >>> 1);  
   186.                     return;  
   187.                 }  
   188.                 // 先是  sc -1 这个操作没有错。应该addcont里面的判断是 是需要减一的，没有在addcount减，放到这里，可以减少操作  
   189.                 if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {  
   190.                     //这个操作会排除 最后进来之前的线程操作。  
   191.                     //怎么做到额，请看addCount方法的 2286行  
   192.                     if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)  
   193.                         return;  
   194.                     finishing = advance = true;  
   195.                     i = n; // recheck before commit  
   196.                 }  
   197.             }  
   198.             else if ((f = tabAt(tab, i)) == null)  
   199.                 advance = casTabAt(tab, i, null, fwd);  
   200.             else if ((fh = f.hash) == MOVED)  
   201.                 advance = true; // already processed  
   202.             else {  
   203.                 //只有对节点操作才会上锁，性能非常  
   204.                 //散列这里与其他版本的不同，散列的思路很好，因为每次扩展都是2倍，那么扩张之后的hash,在进行一次移位，等于1的就在原有的地方加上扩展之前的系数（比如 从16扩展到32，那么hash,下标1的桶，这个桶会分裂成2个桶，一个还在1下表，一个在16+1下标。  
   205.                 synchronized (f) {  
   206.                     if (tabAt(tab, i) == f) {  
   207.                         Node<K,V> ln, hn;  
   208.                         if (fh >= 0) {  
   209.                             int runBit = fh & n;  
   210.                             Node<K,V> lastRun = f;  
   211.                             //寻分裂出来的 lastRun  
   212.                             for (Node<K,V> p = f.next; p != null; p = p.next) {  
   213.                                 int b = p.hash & n;  
   214.                                 if (b != runBit) {  
   215.                                     runBit = b;  
   216.                                     lastRun = p;  
   217.                                 }  
   218.                             }  
   219.                             if (runBit == 0) {  
   220.                                 ln = lastRun;  
   221.                                 hn = null;  
   222.                             }  
   223.                             else {  
   224.                                 hn = lastRun;  
   225.                                 ln = null;  
   226.                             }  
   227.                             //把一个链表，分裂成两个列表  
   228.                             for (Node<K,V> p = f; p != lastRun; p = p.next) {  
   229.                                 int ph = p.hash; K pk = p.key; V pv = p.val;  
   230.                                 if ((ph & n) == 0)  
   231.                                     ln = new Node<K,V>(ph, pk, pv, ln);  
   232.                                 else  
   233.                                     hn = new Node<K,V>(ph, pk, pv, hn);  
   234.                             }  
   235.                             //把两个链表，加入到下个tab  
   236.                             setTabAt(nextTab, i, ln);  
   237.                             setTabAt(nextTab, i + n, hn);  
   238.                             //把分裂的 桶，替换成 fwd  
   239.                             setTabAt(tab, i, fwd);  
   240.                             advance = true;  
   241.                         }  
   242.                         else if (f instanceof TreeBin) {  
   243.                             TreeBin<K,V> t = (TreeBin<K,V>)f;  
   244.                             TreeNode<K,V> lo = null, loTail = null;  
   245.                             TreeNode<K,V> hi = null, hiTail = null;  
   246.                             int lc = 0, hc = 0;  
   247.                             for (Node<K,V> e = t.first; e != null; e = e.next) {  
   248.                                 int h = e.hash;  
   249.                                 TreeNode<K,V> p = new TreeNode<K,V>  
   250.                                     (h, e.key, e.val, null, null);  
   251.                                 if ((h & n) == 0) {  
   252.                                     if ((p.prev = loTail) == null)  
   253.                                         lo = p;  
   254.                                     else  
   255.                                         loTail.next = p;  
   256.                                     loTail = p;  
   257.                                     ++lc;  
   258.                                 }  
   259.                                 else {  
   260.                                     if ((p.prev = hiTail) == null)  
   261.                                         hi = p;  
   262.                                     else  
   263.                                         hiTail.next = p;  
   264.                                     hiTail = p;  
   265.                                     ++hc;  
   266.                                 }  
   267.                             }  
   268.                             ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) :  
   269.                                 (hc != 0) ? new TreeBin<K,V>(lo) : t;  
   270.                             hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) :  
   271.                                 (lc != 0) ? new TreeBin<K,V>(hi) : t;  
   272.                             setTabAt(nextTab, i, ln);  
   273.                             setTabAt(nextTab, i + n, hn);  
   274.                             setTabAt(tab, i, fwd);  
   275.                             advance = true;  
   276.                         }  
   277.                     }  
   278.                 }  
   279.             }  
   280.         }  
   281.     }  
    
10. 看过 jdk8文档的伙计都知道，jdk8，不再是双桶。而进入了 二叉树结构。请看上面的添加操作，与散列操作就知道。TreeBin对象与TreeNode对象就清除了。至于性能怎么样，可以用jdk8文档的标准，性能刚刚的。
11. 使用ForwardingNode对象，保证在散列的时候读写操作是在nextbat里面。非常优秀的设计。
12. 使用Unsafe 对象在性能上带来疯狂的性能提升，但是也给程序设计带来了，超大的复杂性。