yield-bytes

* Head nodes          Index nodes
* +-+    right        +-+                      +-+
* |2|---------------->| |--------------------->| |->null
* +-+                 +-+                      +-+
*  | down              |                        |
*  v                   v                        v
* +-+            +-+  +-+       +-+            +-+       +-+
* |1|----------->| |->| |------>| |----------->| |------>| |->null
* +-+            +-+  +-+       +-+            +-+       +-+
*  v              |    |         |              |         |
* Nodes  next     v    v         v              v         v
* +-+  +-+  +-+  +-+  +-+  +-+  +-+  +-+  +-+  +-+  +-+  +-+
* | |->|A|->|B|->|C|->|D|->|E|->|F|->|G|->|H|->|I|->|J|->|K|->null
* +-+  +-+  +-+  +-+  +-+  +-+  +-+  +-+  +-+  +-+  +-+  +-+

// See LongAdder version for explanation
private final void fullAddCount(long x, boolean wasUncontended) {
    int h;
// 省略部分  ......

package concurrent.demo;
import java.util.concurrent.ConcurrentHashMap;

public class Demo1 {
    static int computeKeyLength(String key){ // 计算key的长度，将其作为该key对应的value
        return key.length();
    }
    public static void  main(String[] args){
        ConcurrentHashMap<String,Integer> map=new ConcurrentHashMap<>();
        map.put("foo",1);
        map.computeIfAbsent("foobar",key->computeKeyLength(key));
        System.out.println(map); //输出 {foobar=6, foo=1}
    }

private final void addCount(long x, int check) {
// 分支1 省略...
  
// 分支2 
if (check >= 0) {
            Node<K,V>[] tab, nt; int n, sc;
            while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
                   (n = tab.length) < MAXIMUM_CAPACITY) {
                int rs = resizeStamp(n); // 注意这里计算出的rs是正值
                if (sc < 0) {
                  	// sc是负值，怎么会等于rs+1或者rs + MAX_RESIZERS这个正值呢？ 有可能是个bug
                    if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
                        sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
                        transferIndex <= 0)
                        break;
                    if (U.compareAndSetInt(this, SIZECTL, sc, sc + 1))
                        transfer(tab, nt);
                }
                else if (U.compareAndSetInt(this, SIZECTL, sc,
                                             (rs << RESIZE_STAMP_SHIFT) + 2))
                    transfer(tab, null);
                s = sumCount();
            }
        }

package concurrent.demo;

public class ResizeStampBugTest {
    public static void main(String[] args) {
      	// 设置64个线程并发put
        int maxThreads = 64;
      	// 初始容量为8，内部会被调整为16
        ConcurrentHashMap<Long, String> map = new ConcurrentHashMap<>(8);
        for (int i = 0; i < maxThreads; i++) {
            Thread t = new Thread(() -> map.put(Thread.currentThread().getId(),Thread.currentThread().getName()));
            t.setName("Thread-"+i);
            t.start();
            // 因为多个线程并发执行不方便查看打印结果，可以让前一个线程领先后面线程一丁点，以便观察打印结果，当然也可以不需要，多执行几次看看打印结果即可。
            // Thread.sleep(1);

        }
    }
}

private static final int MIN_TRANSFER_STRIDE = 4;
// private static final int MIN_TRANSFER_STRIDE = 16;

           else if (U.compareAndSwapInt
                    (this, TRANSFERINDEX, nextIndex,
                     nextBound = (nextIndex > stride ?
                                  nextIndex - stride : 0))) {
               bound = nextBound;
               i = nextIndex - 1;
               advance = false;
// 以下三行是新增代码
               String s=String.format("%s分配的捅位区间为:[%d,%d]并挂起",Thread.currentThread().getName(),bound,i);
               System.out.println(s);
               // 在这里加一句挂起已经分配好桶位区间的线程，用于观察线程
               LockSupport.park(this);
               
           }

         
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
             if (casTabAt(tab, i, null,
                          new Node<K,V>(hash, key, value, null))) {
         // 埋入打印语句
         System.out.println(Thread.currentThread().getName() + "在桶位["+i+"]put入Node节点并退出");

                 break;                   // no lock when adding to empty bin
             }
         }

if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)){
     // 埋入打印语句
        System.out.println(Thread.currentThread().getName()+"后续进入扩容逻辑transfer方法");
        transfer(tab, nt);
    }
}
else if (U.compareAndSwapInt(this, SIZECTL, sc,
                             (rs << RESIZE_STAMP_SHIFT) + 2)){
  	// 埋入打印语句
    System.out.println(Thread.currentThread().getName()+"第1个进入扩容逻辑transfer方法");
    transfer(tab, null);
}

class CachedData {
  // 读线程需要对data读取，写线程可以对data进行更新，那么data显然是线程不安全的，需要借助锁进行相关操作
  Object data;
  volatile boolean cacheValid; // 判断data是否已经被缓存
  // 1、创建一个读写锁
  final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock(); 
 //该方式的功能就是对已经缓存的数据进行预处理 
  void processCachedData() {
    // 2、由于一开始，我们乐观认为data可能已经被缓存，因此我们不急着申请独占锁，而是申请并发的共享读锁
    rwl.readLock().lock();
    // 3、结果发现：我们太乐观了，原来data没缓存，因此还不能读取数据（如果非得去读，只能读到旧数据）
    if (!cacheValid) {
      // Must release read lock before acquiring write lock
      // 4、既然乐观错估了情况，那么只能用上“强大的独占锁”，保证自己能独占的实施“写操作、更新操作、删除操作”：因为读写锁是互斥的，需先释放读锁，然后在升级为写锁。
      // 
      rwl.readLock().unlock();
      // 这就是所谓的“锁升级”。虽然说升级，但这里是当前线程请求独占锁，若同一时刻有其他线程已经拿到写锁，那么在这里当前线程会被阻塞在AQS里面的CLH阻塞队列
      rwl.writeLock().lock(); 
      try {
        // Recheck state because another thread might have
        // acquired write lock and changed state before we did.
        // 5、由于我们获取写锁的时机也许比其他线程晚一步拿到，因此在这里拿到独占锁后，还得重新检查是否data已经提前被其他线程更新过
        if (!cacheValid) {
          data = ... // 例如从数据库重新读取最新的data，然后将cacheValid标记为true，表示data已经更新（或已经更新缓存）
          cacheValid = true; 
        }
        // 6、由于我们还得使用更新后的data，因此可以申请读锁。注意，由于当前线程还持有写锁，因此其他线程不可能获得写锁进行写操作，因此当前线程此时可以申请读锁
        // Downgrade by acquiring read lock before releasing write lock
        rwl.readLock().lock();
      } finally {
        // 7、显然data已经被我“独占式”地更新过，可以释放写锁了
        rwl.writeLock().unlock(); // Unlock write, still hold read
      }
    }

    try {
      // 8、在第6点获得共享的读锁后，在这里可以使用已经缓存的新data
      use(data);
    } finally {
      // 9、释放读锁
      rwl.readLock().unlock();
    }
  }
}

countdownLatch.countDown()  // 使得内部的“计数器值”减1,一般由子线程去调用
countdownLatch.await() // 当内部的“计算器值”为0时，说明所有子线程都已经完成任务，那么阻塞的主线程就会被唤醒再去执行其他任务