VarHandleRefCnt Class — netty Architecture

Source Code

common/src/main/java/io/netty/util/internal/RefCnt.java lines 315–391

    private static final class VarHandleRefCnt {

        private static final VarHandle VH;

        static {
            VH = PlatformDependent.findVarHandleOfIntField(MethodHandles.lookup(), RefCnt.class, "value");
        }

        static void init(RefCnt instance) {
            VH.set(instance, 2);
            VarHandle.storeStoreFence();
        }

        static int refCnt(RefCnt instance) {
            return (int) VH.getAcquire(instance) >>> 1;
        }

        static void retain(RefCnt instance) {
            retain0(instance, 2);
        }

        static void retain(RefCnt instance, int increment) {
            retain0(instance, checkPositive(increment, "increment") << 1);
        }

        private static void retain0(RefCnt instance, int increment) {
            // oldRef & 0x80000001 stands for oldRef < 0 || oldRef is odd
            // NOTE: we're optimizing for inlined and constant folded increment here -> which will make
            // Integer.MAX_VALUE - increment to be computed at compile time
            int oldRef = (int) VH.getAndAdd(instance, increment);
            if ((oldRef & 0x80000001) != 0 || oldRef > Integer.MAX_VALUE - increment) {
                VH.getAndAdd(instance, -increment);
                throw new IllegalReferenceCountException(0, increment >>> 1);
            }
        }

        static boolean release(RefCnt instance) {
            return release0(instance, 2);
        }

        static boolean release(RefCnt instance, int decrement) {
            return release0(instance, checkPositive(decrement, "decrement") << 1);
        }

        private static boolean release0(RefCnt instance, int decrement) {
            int curr, next;
            do {
                curr = (int) VH.get(instance);
                if (curr == decrement) {
                    next = 1;
                } else {
                    if (curr < decrement || (curr & 1) == 1) {
                        throwIllegalRefCountOnRelease(decrement, curr);
                    }
                    next = curr - decrement;
                }
            } while (!(boolean) VH.compareAndSet(instance, curr, next));
            return (next & 1) == 1;
        }

        static void setRefCnt(RefCnt instance, int refCnt) {
            int rawRefCnt = refCnt > 0? refCnt << 1 : 1;
            VH.setRelease(instance, rawRefCnt);
        }

        static void resetRefCnt(RefCnt instance) {
            VH.setRelease(instance, 2);
        }

        static boolean isLiveNonVolatile(RefCnt instance) {
            final int rawCnt = (int) VH.get(instance);
            if (rawCnt == 2) {
                return true;
            }
            return (rawCnt & 1) == 0;
        }
    }