ReferenceCountUpdater Class — netty Architecture

Source Code

common/src/main/java/io/netty/util/internal/ReferenceCountUpdater.java lines 28–168

@Deprecated
public abstract class ReferenceCountUpdater<T extends ReferenceCounted> {
    /*
     * Implementation notes:
     *
     * For the updated int field:
     *   Even => "real" refcount is (refCnt >>> 1)
     *   Odd  => "real" refcount is 0
     */

    protected ReferenceCountUpdater() {
    }

    protected abstract void safeInitializeRawRefCnt(T refCntObj, int value);

    protected abstract int getAndAddRawRefCnt(T refCntObj, int increment);

    protected abstract int getRawRefCnt(T refCnt);

    protected abstract int getAcquireRawRefCnt(T refCnt);

    protected abstract void setReleaseRawRefCnt(T refCnt, int value);

    protected abstract boolean casRawRefCnt(T refCnt, int expected, int value);

    public final int initialValue() {
        return 2;
    }

    public final void setInitialValue(T instance) {
        safeInitializeRawRefCnt(instance, initialValue());
    }

    private static int realRefCnt(int rawCnt) {
        return rawCnt >>> 1;
    }

    public final int refCnt(T instance) {
        return realRefCnt(getAcquireRawRefCnt(instance));
    }

    public final boolean isLiveNonVolatile(T instance) {
        final int rawCnt = getRawRefCnt(instance);
        if (rawCnt == 2) {
            return true;
        }
        return (rawCnt & 1) == 0;
    }

    /**
     * An unsafe operation that sets the reference count directly
     */
    public final void setRefCnt(T instance, int refCnt) {
        int rawRefCnt = refCnt > 0 ? refCnt << 1 : 1; // overflow OK here
        setReleaseRawRefCnt(instance, rawRefCnt);
    }

    /**
     * Resets the reference count to 1
     */
    public final void resetRefCnt(T instance) {
        // no need of a volatile set, it should happen in a quiescent state
        setReleaseRawRefCnt(instance, initialValue());
    }

    public final T retain(T instance) {
        return retain0(instance, 2);
    }

    public final T retain(T instance, int increment) {
        return retain0(instance, checkPositive(increment, "increment") << 1);
    }

    private T retain0(T instance, int increment) {
        int oldRef = getAndAddRawRefCnt(instance, 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
        if ((oldRef & 0x80000001) != 0 || oldRef > Integer.MAX_VALUE - increment) {
            getAndAddRawRefCnt(instance, -increment);
            throw new IllegalReferenceCountException(0, increment >>> 1);