04 ConcurrentHashMap1.8源码深入剖析

最新推荐文章于 2023-06-03 16:35:01 发布
最新推荐文章于 2023-06-03 16:35:01 发布
阅读量188 收藏
点赞数
文章标签： java 数据结构 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yorickjun/article/details/127434230
版权

1 ConcurrentHashMap 的构造方法

/**
* 默认的构造方法为空，不做任何操作，数组长度默认是16
*/
public ConcurrentHashMap() {
}

/**
* 传递初始化容量的构造方法，传递进来一个初始容量，
* ConcurrentHashMap会基于这个值计算一个比这个值大的2的幂次方数作为初始容量
* 与其他版本不同，例如：传递 16 作为参数，它会计算得到 32 作为初始化容量，而不是 16
*/
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;
}

2 添加元素

2.1 sizeCtl 含义解析

这个变量是一个非常重要的变量，而且具有非常丰富的含义，它的值不同，对应的含义也不一样。

1.sizeCtl为0，代表数组未初始化， 且数组的初始容量为16
2.sizeCtl为正数，如果数组未初始化，那么其记录的是数组的初始容量，如果数组已经初始化，那么其记录的是数组的扩容阈值
3.sizeCtl为-1，表示数组正在进行初始化
4.sizeCtl小于0，并且不是-1，表示数组正在扩容， -(1+n)，表示此时有n个线程正在共同完成数组的扩容操作

2.2 put() 方法

/**
* put() 方法会默认调用 putVal() 方法做具体添加元素逻辑
*/
public V put(K key, V value) {
  return putVal(key, value, false);
}

2.3 putval() 方法

/**
* putVal() 方法做具体添加元素逻辑。根据不同的条件进行不同的插入方案选择。
* 大致分为 直接cas插入，链表插入，树插入以及协助扩容等操作。
* 添加完毕后需要对数组元素个数更新，并且判别是否需要扩容。
*/
final V putVal(K key, V value, boolean onlyIfAbsent) {
  // 不接受 null 值，直接抛出空指针异常
  if (key == null || value == null) throw new NullPointerException();
  // 计算 key 的 hash 值
  int hash = spread(key.hashCode());
  // 记录某个桶上元素的个数，如果超过8个，会转成红黑树
  int binCount = 0;
  for (Node<K,V>[] tab = table;;) {
    Node<K,V> f; int n, i, fh;
    // 1.如果数组为空，表示未进行初始化，需要首先进行初始化操作
    if (tab == null || (n = tab.length) == 0)
      tab = initTable();
    // 2.如果 hash 计算得到的桶位置没有元素，利用cas将元素直接添加
    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
    }
    // 3.如果hash计算得到的桶位置元素的hash值为MOVED，证明其他线程正在扩容，那么需要协助扩容
    else if ((fh = f.hash) == MOVED)
      tab = helpTransfer(tab, f);
    // 4.hash 计算的桶位置元素不为空，且当前没有处于扩容操作，进行元素添加
    else {
      V oldVal = null;
      // 对当前桶进行加锁，保证线程安全，执行元素添加操作
      // 普通链表 ： 尾插法
      // 树化后 ： 插入树节点
      // 加锁 为节点头元素添加重量级锁
      synchronized (f) {
        // dcl double check 如果其他线程已经修改头节点，则可以感知
        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;
            }
          }
        }
      }
      if (binCount != 0) {
        // 链表长度大于/等于8，将链表转成红黑树(这个8设计到泊松分布)
        if (binCount >= TREEIFY_THRESHOLD)
          // 树化，因为树化还有满足数组长度是否超过 64
          treeifyBin(tab, i);
        // 如果是重复键，直接将旧值返回
        if (oldVal != null)
          return oldVal;
        break;
      }
    }
  }
  // 添加的是新元素，维护集合长度，并判断是否要进行扩容操作
  addCount(1L, binCount);
  return null;
}

2.4 initTable() 方法

/**
* initTable()方法采用 CAS+自旋的方式线程安全的初始化数组
*/
private final Node<K,V>[] initTable() {
  Node<K,V>[] tab; int sc;
  // cas+自旋，保证线程安全，对数组进行初始化操作
  while ((tab = table) == null || tab.length == 0) {
    // 说明其他线程正在进行初始化，本线程让出 CPU
    if ((sc = sizeCtl) < 0)
      Thread.yield(); // lost initialization race; just spin
    // cas修改sizeCtl的值为-1，修改成功，进行数组初始化，失败，继续自旋
    else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
      try {
        // double check
        if ((tab = table) == null || tab.length == 0) {
          // sizeCtl为0，取默认长度16，否则取用户指定的sizeCtl值
          int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
          @SuppressWarnings("unchecked")
          // 基于初始长度，构建数组对象
          Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
          table = tab = nt;
          // 计算扩容阈值，并赋值给sc，0.75
          sc = n - (n >>> 2);
        }
      } finally {
        // 将扩容阈值，赋值给sizeCtl
        sizeCtl = sc;
      }
      break;
    }
  }
  return tab;
}

3 链表树化

3.1 treeifyBin() 方法

/**
* treeifyBin()方法。首先对数组长度判别，查看是否直接扩容数组即可。
* 之后若满足树化条件，则进行树化的步骤，进行双向链表构建，并进行 TreeBin 对象的构建。
*/
private final void treeifyBin(Node<K,V>[] tab, int index) {
  Node<K,V> b; int n, sc;
  if (tab != null) {
    // 判别当前数组长度是否超过 64(树化阈值)，如果不超过阈值则进行数组的扩容
    // static final int MIN_TREEIFY_CAPACITY = 64;
    if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
      tryPresize(n << 1);
    // 再次核实当前桶存在元素，并且是链表
    else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {
      // 并发安全的进行树化
      synchronized (b) {
        // double check
        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;
          }
          // 将树化后的 TreeBin 对象插入到桶中。具体的树化逻辑与HashMap不同，将TreeNode封装到 TreeBin 对象中，方便平衡树的过程中保证桶中的对象不发生变化。便于对first元素进行加锁操作
          setTabAt(tab, index, new TreeBin<K,V>(hd));
        }
      }
    }
  }
}

3.2 TreeBin 初始化

/**
* TreeBin 的构造方法为具体构建红黑树的逻辑。
*/
TreeBin(TreeNode<K,V> b) {
  super(TREEBIN, null, null, null);
  this.first = b;
  TreeNode<K,V> r = null;
  // 遍历双向链表
  for (TreeNode<K,V> x = b, next; x != null; x = next) {
    next = (TreeNode<K,V>)x.next;
    x.left = x.right = null;
    // 构建红黑树的root节点
    if (r == null) {
      x.parent = null;
      x.red = false;
      r = x;
    }
    // 构建红黑树具体逻辑
    else {
      // 获取元素的 key 和 hash
      K k = x.key;
      int h = x.hash;
      Class<?> kc = null;
      // 遍历红黑树
      for (TreeNode<K,V> p = r;;) {
        int dir, ph;
        K pk = p.key;
        // 向左遍历
        if ((ph = p.hash) > h)
          dir = -1;
        // 向右遍历
        else if (ph < h)
          dir = 1;
        // 根据是否实现 comparable 接口的逻辑判别左右遍历
        else if ((kc == null &&
                  (kc = comparableClassFor(k)) == null) ||
                 (dir = compareComparables(kc, k, pk)) == 0)
          dir = tieBreakOrder(k, pk);
        // 记录父节点
        TreeNode<K,V> xp = p;
        // 构建新节点
        if ((p = (dir <= 0) ? p.left : p.right) == null) {
          x.parent = xp;
          if (dir <= 0)
            xp.left = x;
          else
            xp.right = x;
          // 平衡红黑树
          r = balanceInsertion(r, x);
          break;
        }
      }
    }
  }
  this.root = r;
  assert checkInvariants(root);
}

4 计数操作

jdk1.8中使用了一个仿造LongAdder实现的计数器，让计数操作额外使用别的基于分段并发思想的实现的类。

4.1 addCount() 方法

/**
* addCount() 方法主要包括两个功能：
* 1.记录ConcurrentHashMap元素数量，会调用fullAddCount具体执行
* 2.扩容ConcurrentHashMap ，会调用transer方法具体执行扩容
*/
private final void addCount(long x, int check) {
  CounterCell[] as; long b, s;
  // 当CounterCell数组不为空，则优先利用数组中的CounterCell记录数量
  // 或者当baseCount的累加操作失败，会利用数组中的CounterCell记录数量
  if ((as = counterCells) != null ||
      !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
    CounterCell a; long v; int m;
    // 标识是否有多线程竞争
    boolean uncontended = true;
    // 当as数组为空
    // 或者当as长度小于0
    // 或者当前线程对应的as数组桶位的元素为空
    // 或者当前线程对应的as数组桶位不为空，但是累加失败
    if (as == null || (m = as.length - 1) < 0 ||
        (a = as[ThreadLocalRandom.getProbe() & m]) == null ||
        !(uncontended =
          U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
      // 以上任何一种情况成立，都会进入该方法，传入的uncontended是false
      fullAddCount(x, uncontended);
      return;
    }
    if (check <= 1)
      return;
    // 计算元素个数
    s = sumCount();
  }
  // 接着判断是否需要扩容
  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);
      // sc小于0，说明有线程正在扩容，那么会协助扩容
      if (sc < 0) {
        // 扩容结束或者扩容线程数达到最大值或者扩容后的数组为null或者没有更多的桶位需要转移，结束操作
        if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
            sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
            transferIndex <= 0)
          break;
        // 扩容线程加1，成功后，进行协助扩容操作
        if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
          // 协助扩容，newTable不为null
          transfer(tab, nt);
      }
      // 没有其他线程在进行扩容，达到扩容阈值后，给sizeCtl赋了一个很大的负数
      else if (U.compareAndSwapInt(this, SIZECTL, sc,
                                   (rs << RESIZE_STAMP_SHIFT) + 2))
        // 扩容，newTable为null
        transfer(tab, null);
      s = sumCount();
    }
  }
}

4.2 fullAddCount() 方法

/**
* fullAddCount() 方法用于将需要添加的个数累加到baseCount上，
* 或者累加到其他CountCell数组中的每个对象中的value属性上
*/
private final void fullAddCount(long x, boolean wasUncontended) {
  int h;
  // 获取当前线程的hash值，如果为 0，则重新进行 hash 值计算
  if ((h = ThreadLocalRandom.getProbe()) == 0) {
    ThreadLocalRandom.localInit();      // force initialization
    h = ThreadLocalRandom.getProbe();
    wasUncontended = true;
  }
  boolean collide = false;                // True if last slot nonempty
  for (;;) {
    CounterCell[] as; CounterCell a; int n; long v;
    // 数组不为空，优先对数组中CouterCell的value累加
    if ((as = counterCells) != null && (n = as.length) > 0) {
      // 线程对应的桶为 null
      if ((a = as[(n - 1) & h]) == null) {
        if (cellsBusy == 0) {            // Try to attach new Cell
          // 创建CounterCell对象
          CounterCell r = new CounterCell(x); // Optimistic create
          // 利用CAS修改cellBusy状态为1，成功则将创建的CounterCell对象放入数组中
          if (cellsBusy == 0 &&
              U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
            boolean created = false;
            try {               // Recheck under lock
              CounterCell[] rs; int m, j;
              // double check
              if ((rs = counterCells) != null &&
                  (m = rs.length) > 0 &&
                  rs[j = (m - 1) & h] == null) {
                rs[j] = r;
                // 表示放入成功
                created = true;
              }
            } finally {
              // 重置标志位
              cellsBusy = 0;
            }
            // 成功退出循环
            if (created)
              break
            // 桶已经被别的线程放置了 CounterCell 对象，继续循环
            continue;           // Slot is now non-empty
          }
        }
        collide = false;
      }
      // 桶不为空，重新计算线程hash值，然后继续循环
      else if (!wasUncontended)       // CAS already known to fail
        wasUncontended = true;      // Continue after rehash
      // 重新计算了hash值后，对应的桶位依然不为空，对value累加
      // 成功则结束循环
      // 失败则继续下面判断
      else if (U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))
        break;
      // 数组被别的线程改变了，或者数组长度超过了可用cpu大小，重新计算线程hash值，否则继续下一个判断
      else if (counterCells != as || n >= NCPU)
        collide = false;            // At max size or stale
      // 当没有冲突，修改为有冲突，并重新计算线程hash，继续循环
      else if (!collide)
        collide = true;
      // 如果CounterCell的数组长度没有超过cpu核数，对数组进行两倍扩容
      else if (cellsBusy == 0 &&
               U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
        try {
          // double check
          if (counterCells == as) {// Expand table unless stale
            // 对 CounterCell 数组进行2倍扩容
            CounterCell[] rs = new CounterCell[n << 1];
            for (int i = 0; i < n; ++i)
              rs[i] = as[i];
            counterCells = rs;
          }
        } finally {
          cellsBusy = 0;
        }
        collide = false;
        continue;                   // Retry with expanded table
      }
      // 重新计算 hash 值
      h = ThreadLocalRandom.advanceProbe(h);
    }
    // CounterCell数组为空，并且没有线程在创建数组，修改标记，并创建数组
    else if (cellsBusy == 0 && counterCells == as &&
             U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
      boolean init = false;
      try {                           // Initialize table
        // double check
        if (counterCells == as) {
          // 初始化容量为2的数组
          CounterCell[] rs = new CounterCell[2];
          // 放入 count 计数
          rs[h & 1] = new CounterCell(x);
          counterCells = rs;
          init = true;
        }
      } finally {
        cellsBusy = 0;
      }
      if (init)
        break;
    }
    // 数组为空，并且有别的线程在创建数组，那么尝试对baseCount做累加，成功就退出循环，失败就继续循环
    else if (U.compareAndSwapLong(this, BASECOUNT, v = baseCount, v + x))
      break;                          // Fall back on using base
  }
}

4.3 sumCount() 方法

/**
* sumCount() 方法会聚合所有累加单元和baseCount的值
*/
final long sumCount() {
  CounterCell[] as = counterCells; CounterCell a;
  // 获取baseCount的值
  long sum = baseCount;
  if (as != null) {
    // 遍历CounterCell数组，累加每一个CounterCell的value值
    for (int i = 0; i < as.length; ++i) {
      if ((a = as[i]) != null)
        sum += a.value;
    }
  }
  return sum;
}

5 扩容操作

多线程协助扩容的操作会在两个地方被触发：

① 当添加元素时，发现添加的元素对用的桶位为fwd节点，就会先去协助扩容，然后再添加元素。

② 当添加完元素后，判断当前元素个数达到了扩容阈值，此时发现sizeCtl的值小于0，并且新数组不为空，这个时候，会去协助扩容。

5.1 transfer() 方法

/**
* ConcurrentHashMap触发扩容的时机与HashMap类似，
* 要么是在将链表转换成红黑树时判断table数组的长度是否小于阈值(64)，
* 如果小于就进行扩容而不是树化，要么就是在添加元素的时候，
* 判断当前Entry数量是否超过阈值，如果超过就进行扩容。
*/
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
  int n = tab.length, stride;
  // 如果是多cpu，那么每个线程划分任务，最小任务量是16个桶位的迁移
  if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
    stride = MIN_TRANSFER_STRIDE; // subdivide range
  // 如果是扩容线程，此时新数组为null
  if (nextTab == null) {            // initiating
    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;
  }
  // 记录新数组的长度
  int nextn = nextTab.length;
  // 已迁移的桶，会用这个对象节点占位(这个节点的hash值为-1--MOVED)
  ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
  boolean advance = true;
  boolean finishing = false; // to ensure sweep before committing nextTab
  for (int i = 0, bound = 0;;) {
    Node<K,V> f; int fh;
    while (advance) {
      int nextIndex, nextBound;
      // i记录当前正在迁移桶位的索引值
      // bound记录下一次任务迁移的开始桶位
      // --i >= bound 成立表示当前线程分配的迁移任务还没有完成
      if (--i >= bound || finishing)
        advance = false;
      // 没有元素需要迁移 后续会去将扩容线程数减1，并判断扩容是否完成
      else if ((nextIndex = transferIndex) <= 0) {
        i = -1;
        advance = false;
      }
      // 计算下一次任务迁移的开始桶位置，并将这个值赋值给transferIndex
      else if (U.compareAndSwapInt
               (this, TRANSFERINDEX, nextIndex,
                nextBound = (nextIndex > stride ?
                             nextIndex - stride : 0))) {
        bound = nextBound;
        i = nextIndex - 1;
        advance = false;
      }
    } 
    // 如果没有更多的需要迁移的桶位，就进入该if
    if (i < 0 || i >= n || i + n >= nextn) {
      int sc;
      // 扩容结束后，保存新数组，并重新计算扩容阈值，赋值给sizeCtl
      if (finishing) {
        nextTable = null;
        table = nextTab;
        sizeCtl = (n << 1) - (n >>> 1);
        return;
      }
      // 扩容任务线程数减1
      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
      }
    }
    // 当前迁移的桶位没有元素，直接在该位置添加一个fwd节点
    else if ((f = tabAt(tab, i)) == null)
      advance = casTabAt(tab, i, null, fwd);
    // 当前节点已经被迁移
    else if ((fh = f.hash) == MOVED)
      advance = true; // already processed
    // 当前节点需要迁移，加锁迁移，保证多线程安全
    // 此处迁移逻辑和jdk7的ConcurrentHashMap相同，不再赘述
    else {
      synchronized (f) {
        if (tabAt(tab, i) == f) {
          Node<K,V> ln, hn;
          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;
          }
        }
      }
    }
  }
}

5.2 helpTransfer() 方法

/**
* helpTransfer() 方法是用于其他线程协助扩容的功能。
*/
final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) {
  Node<K,V>[] nextTab; int sc;
  // 当数组不为空并且fwd为占位对象并且扩容的新数组存在时，需要进行协助扩容
  if (tab != null && (f instanceof ForwardingNode) &&
      (nextTab = ((ForwardingNode<K,V>)f).nextTable) != null) {
    int rs = resizeStamp(tab.length);
    // CAS+自旋
    while (nextTab == nextTable && table == tab &&
           (sc = sizeCtl) < 0) {
      // 扩容结束或者扩容线程数达到最大值或者扩容后的数组为null或者没有更多的桶位需要转移，结束操作
      if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
          sc == rs + MAX_RESIZERS || transferIndex <= 0)
        break;
      // 扩容线程加1，成功后，进行协助扩容操作
      if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {
        // 扩容，传递一个不是null的nextTab
        transfer(tab, nextTab);
        break;
      }
    }
    return nextTab;
  }
  return table;
}
攻城老湿
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
【多线程】ConcurrentHashMap1.8源码保姆级解析
aqin1012的博客
06-26 1409
基于一个while循环，先去判断数组初始化了没有，如果没有，会再次比较sizeCtl的情况，如果正在初始化，则会通过Thread.yield()让出CPU资源，如果没有初始化，则会通过CAS的方式修改sizeCtl的值为-1，修改过后还会再次判断数组是否被初始化了（DCL，以免在当前线程修改sizeCtl的值的时候，已经有别的线程对当前数组完成了初始化），如果当前数组仍然没有被初始化，才会真正开始初始化。>0：代表当前数组已经初始化完成，此时sizeCtl的值代表当前数组的扩容阈值，或者数组的初始化大小。
ConcurrentHashMap源码分析(1.8)
FYHannnnnn的博客
01-18 1728
0、说明  1、ConcurrentHashMap跟HashMap，HashTable的对比 2、ConcurrentHashMap原理概览 3、ConcurrentHashMap几个重要概念 4、ConcurrentHashMap几个重要方法 5、ConcurrentHashMap的初始化 6、ConcurrentHashMap的put操作详解 7、ConcurrentHashMap的扩容详解 8、ConcurrentHashMap的get操作详解 9、Con...
深入理解ConcurrentHashMap1.8源码
XHHP
12-31 971
之前介绍了ConcurrentHashMap1.7，采用的是数组+分段锁的方式来实现的。虽然说采用分段锁的方式能够在一定程度上提高并发的效率，但是锁的粒度是Segment级别的，其实还是挺大的。于是，ConcurrentHashMap1.8继续在1.7版本上进行改进，将锁的粒度进一步减小，变成Node级别，又提升了并发的效率。
JDK1.8中ConcurrentHashMap源码解析
小志的博客
11-16 1356
目录一、ConcurrentHashMap使用场景二、put方法的整体流程三、第一种情况（初始化table数组）1、initTable源码如下：2、sizeCtl3、流程解释四、第二种情况（寻址后的位置没有被占用）1、源码如下 一、ConcurrentHashMap使用场景 我们平时最常用的HashMap其实不是线程安全的，而当我们有多线程使用场景的时候，即想线程安全，又想拥有Map的能力，我们可以选择HashTable，因为它是针对我们常用的方法上面加上了synchronize锁，但是在高并发的场景下
ConcurrentHashMap 1.8 源码剖析(超详细)，不懂Java的女朋友们都听懂了
H.CF的博客
02-15 619
本文主要讨论 1.8 的源码实现，1.7的简单掠过 ConcurrentHashMap 1.7 底层实现是数组 + 链表 + segment 分段加锁 ConcurrentHashMap 在1.7中存在的问题 Hash 冲突严重导致节点上的链表过长，到时候遍历链表的效率太低 ConcurrentHashMap 1.8 底层实现是数组 + 链表或者红黑树 + CAS + synchroni...
ConcurrentHashMap源码剖析
11-27
ConcurrentHashMap源码剖析
Java并发系列之ConcurrentHashMap源码分析
08-27
Java并发系列之ConcurrentHashMap源码分析 ConcurrentHashMap是Java中一个高性能的哈希表实现，它解决了HashTable的同步问题，允许多线程同时操作哈希表，从而提高性能。 1. ConcurrentHashMap的成员变量： ...
jdk1.8源码
11-21
《深入解析JDK1.8源码》 JDK（Java Development Kit）是Java开发工具集，是Java语言的核心组成部分，包含了编译器、运行环境、调试工具等。JDK1.8作为Java发展历程中的一个重要版本，引入了许多创新特性，为开发者...
ConcurrentHashMap 核心源码解析
01-21
线程安全的 Map – ConcurrentHashMap，让我们一起研究和 HashMap 相比有何差异，为何能保证线程安全呢. 1 继承体系 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gkf7KyhC-...
hashMap1.8源码
01-19
下面我们将深入探讨HashMap的源码，特别是关于`put`和`get`操作的实现细节。 HashMap的核心数据结构是一个数组配合链表/红黑树的数据结构。数组中的每个元素是一个Node对象，Node包含键、值、哈希码以及指向下一个...
ConcurrentHashMap 1.8源码详解
weixin_44577346的博客
11-15 598
ConcurrentHashMap 1.8源码详解一、jdk1.8容器初始化 一、jdk1.8容器初始化 //没有进行任何操作，在添加数据时才会创建数组 public ConcurrentHashMap() { } //initialCapacity：指定数组初始长度(创建出的数组长度不是这个值) public ConcurrentHashMap(int initialCapacity) { if (initialCapacity < 0) thro
ConcurrentHashMap 1.8源码分析
qq_40102411的博客
03-25 516
ConcurrentHashMap 1.8源码分析
ConcurrentHashMap 源码分析（1.8）
FengZH的博客
12-16 182
文章目录概述主要属性主要内部类NodeForwardingNode构造方法一些重要方法Unsafe 方法initTabletransferputputValget参考 概述 ConcurrentHashMap 是一个加强版的 HashMap，它支持并发操作。比起 HashTable 直接锁住整个数组，ConcurrentHashMap 锁的粒度更细，锁的是单个数组元素，而且有些操作例如初始化，对数...
ConcurrentHashMap1.8源码解析
qq_40790991的博客
04-08 268
1.属性介绍 常量 // 最大容量 private static final int MAXIMUM_CAPACITY = 1 << 30; // 默认容量 private static final int DEFAULT_CAPACITY = 16; // 默认加载因子 private static final float LOAD_FACTOR = 0.75f; // 链表长度树化阈值 static final int TREEIFY_THRESHOLD = 8; // 树形转链表阈值 st
【图解】面试题：ConcurrentHashMap是如何保证线程安全的
Mr 敦（A.Dun）Java历险记
04-25 2947
注意：JDK1.7与JDK1.8中的ConcurrentHashMap主要延续HashMap的设计与思想，是在其基础上进行的相应优化 1.JDK1.7中的底层实现原理 （1）JDK1.7ConcurrentHashMap的底层结构，延续HashMap的底层设计，采用数组+链表 （2）不同的是：ConcurrentHashMap中的数组被分为大数组和小数组，大数组是Segment，小数组是HashEntry Segment本身是基于ReentrantLock可重入锁来实现加锁和释放锁，这样就能保证多线程同.
ConcurrentHashMap源码解析（jdk1.8）
热门推荐
programmer_at的专栏
03-27 3万+
ConcurrentHashMap 基于JDK1.8 ConcurrentHashMap 1. 原理解析 1.1. 重要成员变量 1.2. 实例初始化 1.3. put操作 1.3.1 put过程描述 1.3.2 hash算法 1.3.3 定位索引 1.3.4 获取table对应的索引元素f 1.4. table 扩容 1.4.1 addCount 1.4.2 treeify ...
【java】并发容器之ConcurrentHashMap(JDK 1.8版本)
最新发布
九师兄
06-03 3452
在使用HashMap时在多线程情况下扩容会出现CPU接近100%的情况，因为hashmap并不是线程安全的，通常我们可以使用在java体系中古老的hashtable类，该类基本上所有的方法都采用synchronized进行线程安全的控制，可想而知，在高并发的情况下，每次只有一个线程能够获取对象监视器锁，这样的并发性能的确不令人满意。另外一种方式通过Collections的将hashmap包装成一个线程安全的map。
JUC源码解析-ConcurrentHashMap1.8
业精于勤荒于嬉 行成于思毁于随
06-14 6741
前言 1.8后的ConcurrentHashMap与之前有截然不同的设计，之前是分段锁的思想，通过采用分段锁Segment减少热点域来提高并发效率。1.8利用CAS+Synchronized来保证并发更新的安全，底层采用数组+链表+红黑树的存储结构。 在此再一次膜拜Doug Lea大神，高山仰止。1.8的ConcurrentHashMap有6313行代码，之前大概是1000多行。 这篇文章也...
ConcurrentHashMap1.8源码分析
qq_15047415的博客
02-04 186
1. 查询get方法 1.1 tab位置如何定位 1.1.1 tableSizeFor方法： 在初始化时将tab长度n限制为2的N次方，图1（右）以n=41为例展示tableSizeFor方法的执行过程。 tableSizeFor方法 private static final int tableSizeFor(int c) { int n = c - 1; n |= n >>> 1; n |= n >>> 2; n |
ConcurrentHashMap 1.8代码实现
05-31
ConcurrentHashMap 1.8 是 Java 中线程安全的哈希表实现，它是 Java 5 中引入的 ConcurrentHashMap 的升级版本。以下是 ConcurrentHashMap 1.8 的主要代码实现： 1. 分段锁实现 ConcurrentHashMap 1.8 在内部使用了分段锁（Segment）来实现线程安全。每个 Segment 都是一个独立的哈希表，拥有自己的锁，不同线程可以同时访问不同的 Segment，从而提高并发性能。 2. 数据结构 ConcurrentHashMap 1.8 内部的数据结构是一个 Segment 数组，每个 Segment 内部是一个哈希表，哈希表中的每个元素是一个链表或红黑树。 3. put 操作实现 ConcurrentHashMap 1.8 的 put 操作首先会根据 Key 的哈希值和哈希表的长度计算出元素应该存放在哪个 Segment 中，然后在该 Segment 的哈希表中查找元素。 如果元素已经存在，就直接替换其值；否则就创建一个新的节点并添加到链表或红黑树中。如果链表或红黑树的长度超过了一定阈值，就会将链表转化为红黑树，从而提高查找效率。 4. get 操作实现 ConcurrentHashMap 1.8 的 get 操作与 put 操作类似，首先会根据哈希值和哈希表长度计算出元素所在的 Segment，然后在该 Segment 的哈希表中查找元素。 如果元素存在于链表中，就顺序查找；如果存在于红黑树中，就使用红黑树的查找算法。如果找到了元素，就返回其值；否则返回 null。 5. 扩容实现 ConcurrentHashMap 1.8 的扩容过程与 ConcurrentHashMap 1.7 相比，更加高效。它采用了一种“分段锁粒度更细”的方式，只对需要扩容的 Segment 进行加锁，其他 Segment 可以继续访问，从而提高并发性能。 6. 其他实现细节 ConcurrentHashMap 1.8 还实现了一些其他的细节，例如使用 Unsafe 类来实现 CAS 操作、使用 ThreadLocalRandom 来生成哈希值等，从而保证了其高性能和线程安全性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

攻城老湿

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值