package io.netty.util;

import io.netty.util.concurrent.FastThreadLocal;
import io.netty.util.internal.MathUtil;
import io.netty.util.internal.SystemPropertyUtil;
import io.netty.util.internal.logging.InternalLogger;
import io.netty.util.internal.logging.InternalLoggerFactory;
import java.lang.ref.WeakReference;
import java.util.Arrays;
import java.util.Map;
import java.util.WeakHashMap;
import java.util.concurrent.atomic.AtomicInteger;
import org.snmp4j.mp.PduHandle;

/* JADX INFO: loaded from: classes.dex */
public abstract class Recycler<T> {
    private static final int DEFAULT_INITIAL_MAX_CAPACITY = 262144;
    private static final int DEFAULT_MAX_CAPACITY;
    private static final FastThreadLocal<Map<Stack<?>, WeakOrderQueue>> DELAYED_RECYCLED;
    private static final AtomicInteger ID_GENERATOR;
    private static final int INITIAL_CAPACITY;
    private static final int LINK_CAPACITY;
    private static final int OWN_THREAD_ID;
    private final int maxCapacity;
    private final FastThreadLocal<Stack<T>> threadLocal;
    private static final InternalLogger logger = InternalLoggerFactory.getInstance((Class<?>) Recycler.class);
    private static final Handle NOOP_HANDLE = new Handle() { // from class: io.netty.util.Recycler.1
        @Override // io.netty.util.Recycler.Handle
        public void recycle(Object obj) {
        }
    };

    static final class DefaultHandle<T> implements Handle<T> {
        private int lastRecycledId;
        private int recycleId;
        private Stack<?> stack;
        private Object value;

        DefaultHandle(Stack<?> stack) {
            this.stack = stack;
        }

        @Override // io.netty.util.Recycler.Handle
        public void recycle(Object obj) {
            if (obj != this.value) {
                throw new IllegalArgumentException("object does not belong to handle");
            }
            Thread threadCurrentThread = Thread.currentThread();
            Stack<?> stack = this.stack;
            if (threadCurrentThread == stack.thread) {
                stack.push(this);
                return;
            }
            Map map = (Map) Recycler.DELAYED_RECYCLED.get();
            WeakOrderQueue weakOrderQueue = (WeakOrderQueue) map.get(this.stack);
            if (weakOrderQueue == null) {
                Stack<?> stack2 = this.stack;
                WeakOrderQueue weakOrderQueue2 = new WeakOrderQueue(stack2, threadCurrentThread);
                map.put(stack2, weakOrderQueue2);
                weakOrderQueue = weakOrderQueue2;
            }
            weakOrderQueue.add(this);
        }
    }

    public interface Handle<T> {
        void recycle(T t);
    }

    static final class Stack<T> {
        private WeakOrderQueue cursor;
        private DefaultHandle<?>[] elements;
        private volatile WeakOrderQueue head;
        private final int maxCapacity;
        final Recycler<T> parent;
        private WeakOrderQueue prev;
        private int size;
        final Thread thread;

        Stack(Recycler<T> recycler, Thread thread, int i2) {
            this.parent = recycler;
            this.thread = thread;
            this.maxCapacity = i2;
            this.elements = new DefaultHandle[Math.min(Recycler.INITIAL_CAPACITY, i2)];
        }

        int increaseCapacity(int i2) {
            int length = this.elements.length;
            int i3 = this.maxCapacity;
            do {
                length <<= 1;
                if (length >= i2) {
                    break;
                }
            } while (length < i3);
            int iMin = Math.min(length, i3);
            DefaultHandle<?>[] defaultHandleArr = this.elements;
            if (iMin != defaultHandleArr.length) {
                this.elements = (DefaultHandle[]) Arrays.copyOf(defaultHandleArr, iMin);
            }
            return iMin;
        }

        DefaultHandle<T> newHandle() {
            return new DefaultHandle<>(this);
        }

        DefaultHandle<T> pop() {
            int i2 = this.size;
            if (i2 == 0) {
                if (!scavenge()) {
                    return null;
                }
                i2 = this.size;
            }
            int i3 = i2 - 1;
            Object[] objArr = this.elements;
            DefaultHandle<T> defaultHandle = (DefaultHandle<T>) objArr[i3];
            objArr[i3] = null;
            if (((DefaultHandle) defaultHandle).lastRecycledId != ((DefaultHandle) defaultHandle).recycleId) {
                throw new IllegalStateException("recycled multiple times");
            }
            ((DefaultHandle) defaultHandle).recycleId = 0;
            ((DefaultHandle) defaultHandle).lastRecycledId = 0;
            this.size = i3;
            return defaultHandle;
        }

        void push(DefaultHandle<?> defaultHandle) {
            if ((((DefaultHandle) defaultHandle).recycleId | ((DefaultHandle) defaultHandle).lastRecycledId) != 0) {
                throw new IllegalStateException("recycled already");
            }
            ((DefaultHandle) defaultHandle).recycleId = ((DefaultHandle) defaultHandle).lastRecycledId = Recycler.OWN_THREAD_ID;
            int i2 = this.size;
            int i3 = this.maxCapacity;
            if (i2 >= i3) {
                return;
            }
            DefaultHandle<?>[] defaultHandleArr = this.elements;
            if (i2 == defaultHandleArr.length) {
                this.elements = (DefaultHandle[]) Arrays.copyOf(defaultHandleArr, Math.min(i2 << 1, i3));
            }
            this.elements[i2] = defaultHandle;
            this.size = i2 + 1;
        }

        boolean scavenge() {
            if (scavengeSome()) {
                return true;
            }
            this.prev = null;
            this.cursor = this.head;
            return false;
        }

        boolean scavengeSome() {
            boolean z;
            WeakOrderQueue weakOrderQueue;
            WeakOrderQueue weakOrderQueue2 = this.cursor;
            boolean z2 = false;
            if (weakOrderQueue2 == null && (weakOrderQueue2 = this.head) == null) {
                return false;
            }
            WeakOrderQueue weakOrderQueue3 = this.prev;
            while (true) {
                z = true;
                if (weakOrderQueue2.transfer(this)) {
                    break;
                }
                weakOrderQueue = weakOrderQueue2.next;
                if (weakOrderQueue2.owner.get() == null) {
                    if (weakOrderQueue2.hasFinalData()) {
                        while (weakOrderQueue2.transfer(this)) {
                            z2 = true;
                        }
                    }
                    if (weakOrderQueue3 != null) {
                        weakOrderQueue3.next = weakOrderQueue;
                    }
                } else {
                    weakOrderQueue3 = weakOrderQueue2;
                }
                if (weakOrderQueue == null || z2) {
                    break;
                }
                weakOrderQueue2 = weakOrderQueue;
            }
            z = z2;
            weakOrderQueue2 = weakOrderQueue;
            this.prev = weakOrderQueue3;
            this.cursor = weakOrderQueue2;
            return z;
        }
    }

    private static final class WeakOrderQueue {
        private Link head;
        private final int id = Recycler.ID_GENERATOR.getAndIncrement();
        private WeakOrderQueue next;
        private final WeakReference<Thread> owner;
        private Link tail;

        private static final class Link extends AtomicInteger {
            private final DefaultHandle<?>[] elements;
            private Link next;
            private int readIndex;

            private Link() {
                this.elements = new DefaultHandle[Recycler.LINK_CAPACITY];
            }
        }

        WeakOrderQueue(Stack<?> stack, Thread thread) {
            Link link = new Link();
            this.tail = link;
            this.head = link;
            this.owner = new WeakReference<>(thread);
            synchronized (stack) {
                this.next = ((Stack) stack).head;
                ((Stack) stack).head = this;
            }
        }

        void add(DefaultHandle<?> defaultHandle) {
            ((DefaultHandle) defaultHandle).lastRecycledId = this.id;
            Link link = this.tail;
            int i2 = link.get();
            if (i2 == Recycler.LINK_CAPACITY) {
                link = link.next = new Link();
                this.tail = link;
                i2 = link.get();
            }
            link.elements[i2] = defaultHandle;
            ((DefaultHandle) defaultHandle).stack = null;
            link.lazySet(i2 + 1);
        }

        boolean hasFinalData() {
            return this.tail.readIndex != this.tail.get();
        }

        boolean transfer(Stack<?> stack) {
            Link link = this.head;
            if (link == null) {
                return false;
            }
            if (link.readIndex == Recycler.LINK_CAPACITY) {
                if (link.next == null) {
                    return false;
                }
                link = link.next;
                this.head = link;
            }
            int i2 = link.readIndex;
            int iMin = link.get();
            int i3 = iMin - i2;
            if (i3 == 0) {
                return false;
            }
            int i4 = ((Stack) stack).size;
            int i5 = i3 + i4;
            if (i5 > ((Stack) stack).elements.length) {
                iMin = Math.min((stack.increaseCapacity(i5) + i2) - i4, iMin);
            }
            if (i2 == iMin) {
                return false;
            }
            DefaultHandle[] defaultHandleArr = link.elements;
            DefaultHandle[] defaultHandleArr2 = ((Stack) stack).elements;
            while (i2 < iMin) {
                DefaultHandle defaultHandle = defaultHandleArr[i2];
                if (defaultHandle.recycleId == 0) {
                    defaultHandle.recycleId = defaultHandle.lastRecycledId;
                } else if (defaultHandle.recycleId != defaultHandle.lastRecycledId) {
                    throw new IllegalStateException("recycled already");
                }
                defaultHandle.stack = stack;
                defaultHandleArr2[i4] = defaultHandle;
                defaultHandleArr[i2] = null;
                i2++;
                i4++;
            }
            ((Stack) stack).size = i4;
            if (iMin == Recycler.LINK_CAPACITY && link.next != null) {
                this.head = link.next;
            }
            link.readIndex = iMin;
            return true;
        }
    }

    static {
        AtomicInteger atomicInteger = new AtomicInteger(PduHandle.NONE);
        ID_GENERATOR = atomicInteger;
        OWN_THREAD_ID = atomicInteger.getAndIncrement();
        int i2 = DEFAULT_INITIAL_MAX_CAPACITY;
        int i3 = SystemPropertyUtil.getInt("io.netty.recycler.maxCapacity", DEFAULT_INITIAL_MAX_CAPACITY);
        if (i3 >= 0) {
            i2 = i3;
        }
        DEFAULT_MAX_CAPACITY = i2;
        LINK_CAPACITY = MathUtil.findNextPositivePowerOfTwo(Math.max(SystemPropertyUtil.getInt("io.netty.recycler.linkCapacity", 16), 16));
        if (logger.isDebugEnabled()) {
            int i4 = DEFAULT_MAX_CAPACITY;
            if (i4 == 0) {
                logger.debug("-Dio.netty.recycler.maxCapacity: disabled");
                logger.debug("-Dio.netty.recycler.linkCapacity: disabled");
            } else {
                logger.debug("-Dio.netty.recycler.maxCapacity: {}", Integer.valueOf(i4));
                logger.debug("-Dio.netty.recycler.linkCapacity: {}", Integer.valueOf(LINK_CAPACITY));
            }
        }
        INITIAL_CAPACITY = Math.min(DEFAULT_MAX_CAPACITY, 256);
        DELAYED_RECYCLED = new FastThreadLocal<Map<Stack<?>, WeakOrderQueue>>() { // from class: io.netty.util.Recycler.3
            /* JADX INFO: Access modifiers changed from: protected */
            @Override // io.netty.util.concurrent.FastThreadLocal
            public Map<Stack<?>, WeakOrderQueue> initialValue() {
                return new WeakHashMap();
            }
        };
    }

    protected Recycler() {
        this(DEFAULT_MAX_CAPACITY);
    }

    public final T get() {
        if (this.maxCapacity == 0) {
            return newObject(NOOP_HANDLE);
        }
        Stack<T> stack = this.threadLocal.get();
        DefaultHandle<T> defaultHandlePop = stack.pop();
        if (defaultHandlePop == null) {
            defaultHandlePop = stack.newHandle();
            ((DefaultHandle) defaultHandlePop).value = newObject(defaultHandlePop);
        }
        return (T) ((DefaultHandle) defaultHandlePop).value;
    }

    protected abstract T newObject(Handle<T> handle);

    @Deprecated
    public final boolean recycle(T t, Handle<T> handle) {
        if (handle == NOOP_HANDLE) {
            return false;
        }
        DefaultHandle defaultHandle = (DefaultHandle) handle;
        if (defaultHandle.stack.parent != this) {
            return false;
        }
        defaultHandle.recycle(t);
        return true;
    }

    final int threadLocalCapacity() {
        return ((Stack) this.threadLocal.get()).elements.length;
    }

    final int threadLocalSize() {
        return ((Stack) this.threadLocal.get()).size;
    }

    protected Recycler(int i2) {
        this.threadLocal = new FastThreadLocal<Stack<T>>() { // from class: io.netty.util.Recycler.2
            /* JADX INFO: Access modifiers changed from: protected */
            @Override // io.netty.util.concurrent.FastThreadLocal
            public Stack<T> initialValue() {
                return new Stack<>(Recycler.this, Thread.currentThread(), Recycler.this.maxCapacity);
            }
        };
        this.maxCapacity = Math.max(0, i2);
    }
}