AtomicRefCnt Class — netty Architecture

Source Code

common/src/main/java/io/netty/util/internal/RefCnt.java lines 242–313

    private static final class AtomicRefCnt {
        private static final AtomicIntegerFieldUpdater<RefCnt> UPDATER =
                AtomicIntegerFieldUpdater.newUpdater(RefCnt.class, "value");

        static void init(RefCnt instance) {
            UPDATER.set(instance, 2);
        }

        static int refCnt(RefCnt instance) {
            return UPDATER.get(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 = UPDATER.getAndAdd(instance, increment);
            if ((oldRef & 0x80000001) != 0 || oldRef > Integer.MAX_VALUE - increment) {
                UPDATER.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 = instance.value;
                if (curr == decrement) {
                    next = 1;
                } else {
                    if (curr < decrement || (curr & 1) == 1) {
                        throwIllegalRefCountOnRelease(decrement, curr);
                    }
                    next = curr - decrement;
                }
            } while (!UPDATER.compareAndSet(instance, curr, next));
            return (next & 1) == 1;
        }

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

        static void resetRefCnt(RefCnt instance) {
            UPDATER.lazySet(instance, 2);
        }

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