package io.netty.util;

import io.netty.util.internal.PlatformDependent;
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
import org.snmp4j.mp.MPv3;

/* JADX INFO: loaded from: classes.dex */
public abstract class AbstractReferenceCounted implements ReferenceCounted {
    private static final AtomicIntegerFieldUpdater<AbstractReferenceCounted> refCntUpdater;
    private volatile int refCnt = 1;

    static {
        AtomicIntegerFieldUpdater<AbstractReferenceCounted> atomicIntegerFieldUpdaterNewAtomicIntegerFieldUpdater = PlatformDependent.newAtomicIntegerFieldUpdater(AbstractReferenceCounted.class, "refCnt");
        if (atomicIntegerFieldUpdaterNewAtomicIntegerFieldUpdater == null) {
            atomicIntegerFieldUpdaterNewAtomicIntegerFieldUpdater = AtomicIntegerFieldUpdater.newUpdater(AbstractReferenceCounted.class, "refCnt");
        }
        refCntUpdater = atomicIntegerFieldUpdaterNewAtomicIntegerFieldUpdater;
    }

    protected abstract void deallocate();

    @Override // io.netty.util.ReferenceCounted
    public final int refCnt() {
        return this.refCnt;
    }

    @Override // io.netty.util.ReferenceCounted
    public boolean release() {
        int i2;
        do {
            i2 = this.refCnt;
            if (i2 == 0) {
                throw new IllegalReferenceCountException(0, -1);
            }
        } while (!refCntUpdater.compareAndSet(this, i2, i2 - 1));
        if (i2 != 1) {
            return false;
        }
        deallocate();
        return true;
    }

    @Override // io.netty.util.ReferenceCounted
    public ReferenceCounted retain() {
        int i2;
        do {
            i2 = this.refCnt;
            if (i2 == 0) {
                throw new IllegalReferenceCountException(0, 1);
            }
            if (i2 == Integer.MAX_VALUE) {
                throw new IllegalReferenceCountException(MPv3.MAX_MESSAGE_ID, 1);
            }
        } while (!refCntUpdater.compareAndSet(this, i2, i2 + 1));
        return this;
    }

    protected final void setRefCnt(int i2) {
        this.refCnt = i2;
    }

    @Override // io.netty.util.ReferenceCounted
    public ReferenceCounted touch() {
        return touch(null);
    }

    @Override // io.netty.util.ReferenceCounted
    public boolean release(int i2) {
        int i3;
        if (i2 > 0) {
            do {
                i3 = this.refCnt;
                if (i3 < i2) {
                    throw new IllegalReferenceCountException(i3, -i2);
                }
            } while (!refCntUpdater.compareAndSet(this, i3, i3 - i2));
            if (i3 != i2) {
                return false;
            }
            deallocate();
            return true;
        }
        throw new IllegalArgumentException("decrement: " + i2 + " (expected: > 0)");
    }

    @Override // io.netty.util.ReferenceCounted
    public ReferenceCounted retain(int i2) {
        int i3;
        if (i2 > 0) {
            do {
                i3 = this.refCnt;
                if (i3 == 0) {
                    throw new IllegalReferenceCountException(0, 1);
                }
                if (i3 > MPv3.MAX_MESSAGE_ID - i2) {
                    throw new IllegalReferenceCountException(i3, i2);
                }
            } while (!refCntUpdater.compareAndSet(this, i3, i3 + i2));
            return this;
        }
        throw new IllegalArgumentException("increment: " + i2 + " (expected: > 0)");
    }
}