深入学习java并发包ConcurrentHashMap源码

public ConcurrentHashMap(int initialCapacity,
             float loadFactor, int concurrencyLevel) {
  if (!(loadFactor > 0) || initialCapacity <0 || concurrencyLevel <= 0)
    throw new IllegalArgumentException();
  if (concurrencyLevel > MAX_SEGMENTS)
    cOncurrencyLevel= MAX_SEGMENTS;
  // Find power-of-two sizes best matching arguments
  int sshift = 0;
  int ssize = 1;
  // 计算并行级别 ssize，因为要保持并行级别是 2 的 n 次方
  while (ssize  MAXIMUM_CAPACITY)
    initialCapacity = MAXIMUM_CAPACITY;
  // initialCapacity 是设置整个 map 初始的大小，
  // 这里根据 initialCapacity 计算 Segment 数组中每个位置可以分到的大小
  // 如 initialCapacity 为 64，那么每个 Segment 或称之为"槽"可以分到 4 个
  int c = initialCapacity / ssize;
  if (c * ssize  s0 =
    new Segment(loadFactor, (int)(cap * loadFactor),
             (HashEntry[])new HashEntry[cap]);
  Segment[] ss = (Segment[])new Segment[ssize];
  // 往数组写入 segment[0]
  UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]
  this.segments = ss;
}

static class Segment extends ReentrantLock implements Serializable {
  transient volatile HashEntry[] table;
  transient int count;
  transient int modCount;
  
}

public V put(K key, V value) {
  Segment s;
  if (value == null)
    throw new NullPointerException();
  // 1. 计算 key 的 hash 值
  int hash = hash(key);
  // 2. 根据 hash 值找到 Segment 数组中的位置 j
  //  hash 是 32 位，无符号右移 segmentShift(28) 位，剩下高 4 位，
  //  然后和 segmentMask(15) 做一次与操作，也就是说 j 是 hash 值的高 4 位，也就是槽的数组下标
  int j = (hash >>> segmentShift) & segmentMask;
  // 刚刚说了，初始化的时候初始化了 segment[0]，但是其他位置还是 null，
  // ensureSegment(j) 对 segment[j] 进行初始化
  if ((s = (Segment)UNSAFE.getObject     // nonvolatile; recheck
     (segments, (j <

private Segment ensureSegment(int k) {
  final Segment[] ss = this.segments;
  long u = (k < seg;
  if ((seg = (Segment)UNSAFE.getObjectVolatile(ss, u)) == null) {
    // 这里看到为什么之前要初始化 segment[0] 了，
    // 使用当前 segment[0] 处的数组长度和负载因子来初始化 segment[k]
    // 为什么要用“当前”，因为 segment[0] 可能早就扩容过了
    Segment proto = ss[0];
    int cap = proto.table.length;
    float lf = proto.loadFactor;
    int threshold = (int)(cap * lf);
    // 初始化 segment[k] 内部的数组
    HashEntry[] tab = (HashEntry[])new HashEntry[cap];
    if ((seg = (Segment)UNSAFE.getObjectVolatile(ss, u))
      == null) { // 再次检查一遍该槽是否被其他线程初始化了。
      Segment s = new Segment(lf, threshold, tab);
      // 使用 while 循环，内部用 CAS，当前线程成功设值或其他线程成功设值后，退出,如果其他线程成功设置后，这里获取到直接返回
      while ((seg = (Segment)UNSAFE.getObjectVolatile(ss, u))
          == null) {
        if (UNSAFE.compareAndSwapObject(ss, u, null, seg = s))
          break;
      }
    }
  }
  return seg;
}

final V put(K key, int hash, V value, boolean onlyIfAbsent) {
  // 在往该 segment 写入前，需要先获取该 segment 的独占锁
  //  先看主流程，后面还会具体介绍这部分内容
  HashEntry node = tryLock() &＃63; null :
    scanAndLockForPut(key, hash, value);
  V oldValue;
  try {
    // 这个是 segment 内部的数组
    HashEntry[] tab = table;
    // 再利用 hash 值，求应该放置的数组下标
    int index = (tab.length - 1) & hash;
    // first 是数组该位置处的链表的表头
    HashEntry first = entryAt(tab, index);

    // 下面这串 for 循环虽然很长，不过也很好理解，想想该位置没有任何元素和已经存在一个链表这两种情况
    for (HashEntry e = first;;) {
      if (e != null) {
        K k;
        if ((k = e.key) == key ||
          (e.hash == hash && key.equals(k))) {
          oldValue = e.value;
          if (!onlyIfAbsent) {
            // 覆盖旧值
            e.value = value;
            ++modCount;
          }
          break;
        }
        // 继续顺着链表走
        e = e.next;
      }
      else {
        // node 到底是不是 null，这个要看获取锁的过程，不过和这里都没有关系。
        // 如果不为 null，那就直接将它设置为链表表头；如果是null，初始化并设置为链表表头。
        if (node != null)
          node.setNext(first);
        else
          node = new HashEntry(hash, key, value, first);

        int c = count + 1;
        // 如果超过了该 segment 的阈值，这个 segment 需要扩容
        if (c > threshold && tab.length 

private HashEntry scanAndLockForPut(K key, int hash, V value) {
  HashEntry first = entryForHash(this, hash);
  HashEntry e = first;
  HashEntry node = null;
  int retries = -1; // negative while locating node
  // 循环获取锁
  while (!tryLock()) {
    HashEntry f; // to recheck first below
    if (retries <0) {
      if (e == null) {
        if (node == null) // speculatively create node
          // 进到这里说明数组该位置的链表是空的，没有任何元素
          // 当然，进到这里的另一个原因是 tryLock() 失败，所以该槽存在并发，不一定是该位置
          node = new HashEntry(hash, key, value, null);
        retries = 0;
      }
      else if (key.equals(e.key))
        retries = 0;
      else
        // 顺着链表往下走
        e = e.next;
    }
    // 重试次数如果超过 MAX_SCAN_RETRIES（单核1多核64），那么不抢了，进入到阻塞队列等待锁
    //  lock() 是阻塞方法，直到获取锁后返回
    else if (++retries > MAX_SCAN_RETRIES) {
      lock();
      break;
    }
    else if ((retries & 1) == 0 &&
         // 这个时候是有大问题了，那就是有新的元素进到了链表，成为了新的表头
         //   所以这边的策略是，相当于重新走一遍这个 scanAndLockForPut 方法
         (f = entryForHash(this, hash)) != first) {
      e = first = f; // re-traverse if entry changed
      retries = -1;
    }
  }
  return node;
}

// 方法参数上的 node 是这次扩容后，需要添加到新的数组中的数据。
private void rehash(HashEntry node) {
  HashEntry[] oldTable = table;
  int oldCapacity = oldTable.length;
  // 2 倍
  int newCapacity = oldCapacity <<1;
  threshold = (int)(newCapacity * loadFactor);
  // 创建新数组
  HashEntry[] newTable =
    (HashEntry[]) new HashEntry[newCapacity];
  // 新的掩码，如从 16 扩容到 32，那么 sizeMask 为 31，对应二进制 ‘000...00011111'
  int sizeMask = newCapacity - 1;

  // 遍历原数组，老套路，将原数组位置 i 处的链表拆分到 新数组位置 i 和 i+oldCap 两个位置
  for (int i = 0; i  e = oldTable[i];
    if (e != null) {
      HashEntry next = e.next;
      // 计算应该放置在新数组中的位置，
      // 假设原数组长度为 16，e 在 oldTable[3] 处，那么 idx 只可能是 3 或者是 3 + 16 = 19
      int idx = e.hash & sizeMask;
      if (next == null)  // 该位置处只有一个元素，那比较好办
        newTable[idx] = e;
      else { // Reuse consecutive sequence at same slot
        // e 是链表表头
        HashEntry lastRun = e;
        // idx 是当前链表的头结点 e 的新位置
        int lastIdx = idx;

        // 下面这个 for 循环会找到一个 lastRun 节点，这个节点之后的所有元素是将要放到一起的
        for (HashEntry last = next;
           last != null;
           last = last.next) {
          int k = last.hash & sizeMask;
          if (k != lastIdx) {
            lastIdx = k;
            lastRun = last;
          }
        }
        // 将 lastRun 及其之后的所有节点组成的这个链表放到 lastIdx 这个位置
        newTable[lastIdx] = lastRun;
        // 下面的操作是处理 lastRun 之前的节点，
        //  这些节点可能分配在另一个链表中，也可能分配到上面的那个链表中
        for (HashEntry p = e; p != lastRun; p = p.next) {
          V v = p.value;
          int h = p.hash;
          int k = h & sizeMask;
          HashEntry n = newTable[k];
          newTable[k] = new HashEntry(h, p.key, v, n);
        }
      }
    }
  }
  // 将新来的 node 放到新数组中刚刚的 两个链表之一 的 头部
  int nodeIndex = node.hash & sizeMask; // add the new node
  node.setNext(newTable[nodeIndex]);
  newTable[nodeIndex] = node;
  table = newTable;
}

public V get(Object key) {
  Segment s; // manually integrate access methods to reduce overhead
  HashEntry[] tab;
  // 1. hash 值
  int h = hash(key);
  long u = (((h >>> segmentShift) & segmentMask) <)UNSAFE.getObjectVolatile(segments, u)) != null &&
    (tab = s.table) != null) {
    // 3. 找到segment 内部数组相应位置的链表，遍历
    for (HashEntry e = (HashEntry) UNSAFE.getObjectVolatile
         (tab, ((long)(((tab.length - 1) & h)) <

public int size() {
 final Segment[] segments = this.segments;
 int size;
 boolean overflow; // true if size overflows 32 bits
 long sum;     // sum of modCounts
 long last = 0L;  // previous sum
 int retries = -1; // first iteration isn't retry
 try {
  for (;;) {
   if (retries++ == RETRIES_BEFORE_LOCK) {
    for (int j = 0; j  seg = segmentAt(segments, j);
    if (seg != null) {
     sum += seg.modCount;
     int c = seg.count;
     if (c <0 || (size += c) <0)
      overflow = true;
    }
   }
   if (sum == last)
    break;
   last = sum;
  }
 } finally {
  if (retries > RETRIES_BEFORE_LOCK) {
   for (int j = 0; j