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;

/* 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 Handle NOOP_HANDLE;
    private static final int OWN_THREAD_ID;
    private static final InternalLogger logger;
    private final int maxCapacity;
    private final FastThreadLocal<Stack<T>> threadLocal;

    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 i) {
            this.parent = recycler;
            this.thread = thread;
            this.maxCapacity = i;
            this.elements = new DefaultHandle[Math.min(Recycler.INITIAL_CAPACITY, i)];
        }

        int increaseCapacity(int i) {
            int length = this.elements.length;
            int i2 = this.maxCapacity;
            do {
                length <<= 1;
                if (length >= i) {
                    break;
                }
            } while (length < i2);
            int iMin = Math.min(length, i2);
            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 i = this.size;
            if (i == 0) {
                if (!scavenge()) {
                    return null;
                }
                i = this.size;
            }
            int i2 = i - 1;
            Object[] objArr = this.elements;
            DefaultHandle<T> defaultHandle = (DefaultHandle<T>) objArr[i2];
            objArr[i2] = null;
            if (((DefaultHandle) defaultHandle).lastRecycledId != ((DefaultHandle) defaultHandle).recycleId) {
                throw new IllegalStateException("recycled multiple times");
            }
            ((DefaultHandle) defaultHandle).recycleId = 0;
            ((DefaultHandle) defaultHandle).lastRecycledId = 0;
            this.size = i2;
            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 i = this.size;
            int i2 = this.maxCapacity;
            if (i >= i2) {
                return;
            }
            DefaultHandle<?>[] defaultHandleArr = this.elements;
            if (i == defaultHandleArr.length) {
                this.elements = (DefaultHandle[]) Arrays.copyOf(defaultHandleArr, Math.min(i << 1, i2));
            }
            this.elements[i] = defaultHandle;
            this.size = i + 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 i = link.get();
            if (i == Recycler.LINK_CAPACITY) {
                link = link.next = new Link();
                this.tail = link;
                i = link.get();
            }
            link.elements[i] = defaultHandle;
            ((DefaultHandle) defaultHandle).stack = null;
            link.lazySet(i + 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 i = link.readIndex;
            int iMin = link.get();
            int i2 = iMin - i;
            if (i2 == 0) {
                return false;
            }
            int i3 = ((Stack) stack).size;
            int i4 = i2 + i3;
            if (i4 > ((Stack) stack).elements.length) {
                iMin = Math.min((stack.increaseCapacity(i4) + i) - i3, iMin);
            }
            if (i == iMin) {
                return false;
            }
            DefaultHandle[] defaultHandleArr = link.elements;
            DefaultHandle[] defaultHandleArr2 = ((Stack) stack).elements;
            while (i < iMin) {
                DefaultHandle defaultHandle = defaultHandleArr[i];
                if (defaultHandle.recycleId == 0) {
                    defaultHandle.recycleId = defaultHandle.lastRecycledId;
                } else if (defaultHandle.recycleId != defaultHandle.lastRecycledId) {
                    throw new IllegalStateException("recycled already");
                }
                defaultHandle.stack = stack;
                defaultHandleArr2[i3] = defaultHandle;
                defaultHandleArr[i] = null;
                i++;
                i3++;
            }
            ((Stack) stack).size = i3;
            if (iMin == Recycler.LINK_CAPACITY && link.next != null) {
                this.head = link.next;
            }
            link.readIndex = iMin;
            return true;
        }
    }

    static {
        InternalLogger internalLoggerFactory = InternalLoggerFactory.getInstance((Class<?>) Recycler.class);
        logger = internalLoggerFactory;
        NOOP_HANDLE = new Handle() { // from class: io.netty.util.Recycler.1
            @Override // io.netty.util.Recycler.Handle
            public void recycle(Object obj) {
            }
        };
        AtomicInteger atomicInteger = new AtomicInteger(Integer.MIN_VALUE);
        ID_GENERATOR = atomicInteger;
        OWN_THREAD_ID = atomicInteger.getAndIncrement();
        int i = DEFAULT_INITIAL_MAX_CAPACITY;
        int i2 = SystemPropertyUtil.getInt("io.netty.recycler.maxCapacity", DEFAULT_INITIAL_MAX_CAPACITY);
        if (i2 >= 0) {
            i = i2;
        }
        DEFAULT_MAX_CAPACITY = i;
        int iFindNextPositivePowerOfTwo = MathUtil.findNextPositivePowerOfTwo(Math.max(SystemPropertyUtil.getInt("io.netty.recycler.linkCapacity", 16), 16));
        LINK_CAPACITY = iFindNextPositivePowerOfTwo;
        if (internalLoggerFactory.isDebugEnabled()) {
            if (i == 0) {
                internalLoggerFactory.debug("-Dio.netty.recycler.maxCapacity: disabled");
                internalLoggerFactory.debug("-Dio.netty.recycler.linkCapacity: disabled");
            } else {
                internalLoggerFactory.debug("-Dio.netty.recycler.maxCapacity: {}", Integer.valueOf(i));
                internalLoggerFactory.debug("-Dio.netty.recycler.linkCapacity: {}", Integer.valueOf(iFindNextPositivePowerOfTwo));
            }
        }
        INITIAL_CAPACITY = Math.min(i, 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 i) {
        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, i);
    }
}