扩容条件就进行扩容，并且扩容步长为 4 (INDEX_INCREMENT)

    private void record(int actualReadBytes) {
        if (actualReadBytes <= SIZE_TABLE[max(0, index - INDEX_DECREMENT)]) {
            // 缩容条件触发两次之后就进行缩容
            if (decreaseNow) {
                index = max(index - INDEX_DECREMENT, minIndex);
                nextReceiveBufferSize = SIZE_TABLE[index];
                decreaseNow = false;
            } else {
                decreaseNow = true;
            }
        } else if (actualReadBytes >= nextReceiveBufferSize) {
            // 扩容条件满足一次之后就进行扩容
            index = min(index + INDEX_INCREMENT, maxIndex);
            nextReceiveBufferSize = SIZE_TABLE[index];
            decreaseNow = false;
        }
    }public abstract class AbstractReferenceCountedByteBuf extends AbstractByteBuf {
// 原子更新 refCnt 的 Updater
private static final AtomicIntegerFieldUpdater<AbstractReferenceCountedByteBuf> refCntUpdater =
        AtomicIntegerFieldUpdater.newUpdater(AbstractReferenceCountedByteBuf.class, "refCnt");
// 引用计数，初始化为 1
private volatile int refCnt;

protected AbstractReferenceCountedByteBuf(int maxCapacity) {
    super(maxCapacity);
    // 引用计数初始化为 1
    refCntUpdater.set(this, 1);
}
        }
        // CAS 更新 refCnt
        if (refCntUpdater.compareAndSet(this, refCnt, nextCnt)) {
            break;
        }
    }
    return this;
}https://www.laipuhuo.com/goodsDetail/01ed3b6143214668897d8af195325e77.html

www.laipuhuo.com/goodsDetail… www.laipuhuo.com/goodsDetail… www.laipuhuo.com/goodsDetail… www.laipuhuo.com/goodsDetail… www.laipuhuo.com/goodsDetail… www.laipuhuo.com/goodsDetail… www.laipuhuo.com/goodsDetail… www.laipuhuo.com/goodsDetail… www.laipuhuo.com/goodsDetail…

// 引用计数减少 decrement
private boolean release0(int decrement) {
    for (;;) {
        int refCnt = this.refCnt;
        if (refCnt < decrement) {
            // 引用的次数必须和释放的次数相等对应
            throw new IllegalReferenceCountException(refCnt, -decrement);
        }
        // 每次 release 引用计数减 1 
        // CAS 更新 refCnt
        if (refCntUpdater.compareAndSet(this, refCnt, refCnt - decrement)) {
            if (refCnt == decrement) {
                // 如果引用计数为 0 ，则释放 Native Memory，并返回 true
                deallocate();
                return true;
            }
            // 引用计数不为 0 ，返回 false
            return false;
        }
    }
}

}

public abstract class AbstractReferenceCountedByteBuf extends AbstractByteBuf { // 原子更新 refCnt 的 Updater private static final AtomicIntegerFieldUpdater refCntUpdater = AtomicIntegerFieldUpdater.newUpdater(AbstractReferenceCountedByteBuf.class, "refCnt"); // 引用计数，初始化为 1 private volatile int refCnt;

protected AbstractReferenceCountedByteBuf(int maxCapacity) {
    super(maxCapacity);
    // 引用计数初始化为 1
    refCntUpdater.set(this, 1);
}

// 引用计数增加 increment
private ByteBuf retain0(int increment) {
    for (;;) {
        int refCnt = this.refCnt;
        // 每次 retain 的时候对引用计数加 1
        final int nextCnt = refCnt + increment;

        // Ensure we not resurrect (which means the refCnt was 0) and also that we encountered an overflow.
        if (nextCnt <= increment) {
            // 如果 refCnt 已经为 0 或者发生溢出，则抛异常
            throw new IllegalReferenceCountException(refCnt, increment);
        }
        // CAS 更新 refCnt
        if (refCntUpdater.compareAndSet(this, refCnt, nextCnt)) {
            break;
        }
    }
    return this;
}

            return false;
        }
    }
}

}