Java 在ConcurrentHashMap'；s传输方法，I不'；“我不理解这两个条件的含义”；i>；="；及；i+；n>；=nextn"；

在传输方法中，如果（i<0 | | i>=n | i+n>=nextn），则判断扩展终止（或帮助传输线程完成）的条件为

{

。我知道

I<0

这个条件意味着所有箱子都已分配，但我不理解其他两个条件的含义：

I>=n

和

I+n>=nextn

是否考虑到数据溢出？（-2147483648-1=2147483647）

i+n>=nextn

与

i>=n

相同吗？（我不这么认为）

私有最终无效转移（节点[]选项卡，节点[]下一个选项卡）{
int n=制表符长度，步幅；
//...
int nextn=nextTab.length；
ForwardingNode fwd=新的ForwardingNode（nextTab）；
布尔前进=真；
boolean finishing=false；//在提交下一个TTAB之前确保扫描
对于（int i=0，bound=0；；）{
节点f；
而（预付款）{
int nextIndex，NEXTBOND；
如果（--i>=绑定| |整理）
提前=假；
否则如果（（nextIndex=transferIndex）跨步？
nextIndex-步幅：0）{
绑定=下一个绑定；
i=nextIndex-1；
提前=假；
}
}
如果（i<0 | i>=n | i+n>=nextn）{
int sc；
如果（精加工）{
nextTable=null；
表=nextTab；
sizeCtl=（n>>1）；
返回；
}
如果（U.compareAndSwapInt（this，SIZECTL，sc=SIZECTL，sc-1））{
如果（（sc-2）！=resizeStamp（n）逻辑上是一段死代码，我认为它可能是编码/解包过程中的边界检测

从数学的角度来看，如果i>=n，那么

int溢出：不可能。因为最大大小调整阈值是1，所以这行也在做什么？：
int n=tab.length，stride；
讽刺的是，通过一个生锈的实现，我自己也遇到了类似的问题。@4:05:02Doh..分配了2个int变量n和stride..并将tab.length分配给n。我打赌Jon能够回答这个问题问题！Jon在第二段视频开始时还从10000英尺的高度对算法的工作原理进行了很好的概述。也许值得一看；谢谢，我在中国，不能看YouTube，所以我在获得VPN后会看：）你有权访问Twitter吗？jonhoo是Jon Gjengset的推特手柄，是他干的。也许你可以通过Twitter问他？
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
        int n = tab.length, stride;
        //...
        int nextn = nextTab.length;
        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;
                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
                }
            }
            //...
}

while (advance) {
  int nextIndex, nextBound;
  if (--i >= bound || finishing)
      advance = false;
  else if ((nextIndex = transferIndex) <= 0) { //here is the only chance to update nextIndex
      i = -1;
      advance = false;
  }
  else if (U.compareAndSwapInt
           (this, TRANSFERINDEX, nextIndex,
            nextBound = (nextIndex > stride ?
                         nextIndex - stride : 0))) {
      bound = nextBound;
      i = nextIndex - 1;
      advance = false;
  }
}