ConcurrentHashMap resizeStamp方法如何工作？

Question

In the source code of ConcurrentHashMap , there is a method called resizeStamp , the code is:

static final int resizeStamp(int n) {
    return Integer.numberOfLeadingZeros(n) | (1 << (RESIZE_STAMP_BITS - 1));
}

How does this code work?

Answer 1

Short Answer: take sc as the result of (resizeStamp(n) << RESIZE_STAMP_SHIFT) , the higher 16 bit of sc tells the information that there are at least one thread doing resizing operation on capcity n ， the lower 16 bit tells the information that how many theards are doing this resizing concurrently.

Explaination:

First, checkout the documentation of resizeStamp(n)

/**
 * Returns the stamp bits for resizing a table of size n.
 * Must be negative when shifted left by RESIZE_STAMP_SHIFT.
 */
static final int resizeStamp(int n) {
    return Integer.numberOfLeadingZeros(n) | (1 << (RESIZE_STAMP_BITS - 1));
}

so this function clearly do two things

1. compute leading zero numbers of n as tmpReuslt
2. make the 16th bit of tmpResult be 1 ( Notice: RESIZE_STAMP_BITS is a constant which equals 16 )

so resizeStamp return a 32-bit int value which has format 0000 0000 0000 0000 1xxx xxx xxxx xxxx

as the documentation says, the return result " Must be negative when shifted left by RESIZE_STAMP_SHIFT" .

Obviously, when the 16th bit is set to 1, when shifted left by RESIZE_STAMP_SHIFT , the highest bit of the reuslt would be 1, which make it a negative number.

Then, the second question comes, why does it do this, checkout the addCount(long x, int check) function in ConcurrentHashMap

 // some code here
 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);
            if (sc < 0) {
                if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
                    sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
                    transferIndex <= 0)
                    break;
                if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
                    transfer(tab, nt);
            }
            else if (U.compareAndSwapInt(this, SIZECTL, sc,
                                         (rs << RESIZE_STAMP_SHIFT) + 2))
                transfer(tab, null);
            s = sumCount();
        }
    }

resizeStamp is used to assgin value of sizeCtl in ConcurrentHashMap, by operation (rs << RESIZE_STAMP_SHIFT) + 2 .

resizeStamp function ensures sizeCtl gets a negative value if

U.compareAndSwapInt(this, SIZECTL, sc,(rs << RESIZE_STAMP_SHIFT) + 2) 

executed successfully.

• And the higher 16 bit of sizeCtl can tell the information : on which size n , the resizing operation is going on