UnsafeRefCnt Class — netty Architecture

Source Code

common/src/main/java/io/netty/util/internal/RefCnt.java lines 393–475

    private static final class UnsafeRefCnt {

        private static final long VALUE_OFFSET = getUnsafeOffset(RefCnt.class, "value");

        private static long getUnsafeOffset(Class<?> clz, String fieldName) {
            try {
                if (PlatformDependent.hasUnsafe()) {
                    return PlatformDependent.objectFieldOffset(clz.getDeclaredField(fieldName));
                }
            } catch (Throwable ignore) {
                // fall-back
            }
            return -1;
        }

        static void init(RefCnt instance) {
            PlatformDependent.safeConstructPutInt(instance, VALUE_OFFSET, 2);
        }

        static int refCnt(RefCnt instance) {
            return PlatformDependent.getVolatileInt(instance, VALUE_OFFSET) >>> 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 = PlatformDependent.getAndAddInt(instance, VALUE_OFFSET, increment);
            if ((oldRef & 0x80000001) != 0 || oldRef > Integer.MAX_VALUE - increment) {
                PlatformDependent.getAndAddInt(instance, VALUE_OFFSET, -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 = PlatformDependent.getInt(instance, VALUE_OFFSET);
                if (curr == decrement) {
                    next = 1;
                } else {
                    if (curr < decrement || (curr & 1) == 1) {
                        throwIllegalRefCountOnRelease(decrement, curr);
                    }
                    next = curr - decrement;
                }
            } while (!PlatformDependent.compareAndSwapInt(instance, VALUE_OFFSET, curr, next));
            return (next & 1) == 1;
        }

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

        static void resetRefCnt(RefCnt instance) {
            PlatformDependent.putOrderedInt(instance, VALUE_OFFSET, 2);
        }

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