package io.netty.util.concurrent;

import io.netty.util.internal.InternalThreadLocalMap;
import io.netty.util.internal.ObjectCleaner;
import io.netty.util.internal.PlatformDependent;
import java.util.Collections;
import java.util.IdentityHashMap;
import java.util.Set;

/* JADX INFO: loaded from: classes.dex */
public class FastThreadLocal<V> {
    private static final int variablesToRemoveIndex = InternalThreadLocalMap.nextVariableIndex();
    private final int index = InternalThreadLocalMap.nextVariableIndex();
    private final int cleanerFlagIndex = InternalThreadLocalMap.nextVariableIndex();

    private static void addToVariablesToRemove(InternalThreadLocalMap internalThreadLocalMap, FastThreadLocal<?> fastThreadLocal) {
        Set setNewSetFromMap;
        int i2 = variablesToRemoveIndex;
        Object objIndexedVariable = internalThreadLocalMap.indexedVariable(i2);
        if (objIndexedVariable == InternalThreadLocalMap.UNSET || objIndexedVariable == null) {
            setNewSetFromMap = Collections.newSetFromMap(new IdentityHashMap());
            internalThreadLocalMap.setIndexedVariable(i2, setNewSetFromMap);
        } else {
            setNewSetFromMap = (Set) objIndexedVariable;
        }
        setNewSetFromMap.add(fastThreadLocal);
    }

    public static void destroy() {
        InternalThreadLocalMap.destroy();
    }

    private V initialize(InternalThreadLocalMap internalThreadLocalMap) {
        V vInitialValue;
        try {
            vInitialValue = initialValue();
        } catch (Exception e2) {
            PlatformDependent.throwException(e2);
            vInitialValue = null;
        }
        internalThreadLocalMap.setIndexedVariable(this.index, vInitialValue);
        addToVariablesToRemove(internalThreadLocalMap, this);
        return vInitialValue;
    }

    private void registerCleaner(final InternalThreadLocalMap internalThreadLocalMap) {
        Thread threadCurrentThread = Thread.currentThread();
        if (FastThreadLocalThread.willCleanupFastThreadLocals(threadCurrentThread) || internalThreadLocalMap.indexedVariable(this.cleanerFlagIndex) != InternalThreadLocalMap.UNSET) {
            return;
        }
        internalThreadLocalMap.setIndexedVariable(this.cleanerFlagIndex, Boolean.TRUE);
        ObjectCleaner.register(threadCurrentThread, new Runnable() { // from class: io.netty.util.concurrent.FastThreadLocal.1
            @Override // java.lang.Runnable
            public void run() {
                FastThreadLocal.this.remove(internalThreadLocalMap);
            }
        });
    }

    public static void removeAll() {
        InternalThreadLocalMap ifSet = InternalThreadLocalMap.getIfSet();
        if (ifSet == null) {
            return;
        }
        try {
            Object objIndexedVariable = ifSet.indexedVariable(variablesToRemoveIndex);
            if (objIndexedVariable != null && objIndexedVariable != InternalThreadLocalMap.UNSET) {
                Set set = (Set) objIndexedVariable;
                for (FastThreadLocal fastThreadLocal : (FastThreadLocal[]) set.toArray(new FastThreadLocal[set.size()])) {
                    fastThreadLocal.remove(ifSet);
                }
            }
        } finally {
            InternalThreadLocalMap.remove();
        }
    }

    private static void removeFromVariablesToRemove(InternalThreadLocalMap internalThreadLocalMap, FastThreadLocal<?> fastThreadLocal) {
        Object objIndexedVariable = internalThreadLocalMap.indexedVariable(variablesToRemoveIndex);
        if (objIndexedVariable == InternalThreadLocalMap.UNSET || objIndexedVariable == null) {
            return;
        }
        ((Set) objIndexedVariable).remove(fastThreadLocal);
    }

    private boolean setKnownNotUnset(InternalThreadLocalMap internalThreadLocalMap, V v2) {
        if (!internalThreadLocalMap.setIndexedVariable(this.index, v2)) {
            return false;
        }
        addToVariablesToRemove(internalThreadLocalMap, this);
        return true;
    }

    public static int size() {
        InternalThreadLocalMap ifSet = InternalThreadLocalMap.getIfSet();
        if (ifSet == null) {
            return 0;
        }
        return ifSet.size();
    }

    public final V get() {
        InternalThreadLocalMap internalThreadLocalMap = InternalThreadLocalMap.get();
        V v2 = (V) internalThreadLocalMap.indexedVariable(this.index);
        if (v2 != InternalThreadLocalMap.UNSET) {
            return v2;
        }
        V vInitialize = initialize(internalThreadLocalMap);
        registerCleaner(internalThreadLocalMap);
        return vInitialize;
    }

    public final V get(InternalThreadLocalMap internalThreadLocalMap) {
        V v2 = (V) internalThreadLocalMap.indexedVariable(this.index);
        return v2 != InternalThreadLocalMap.UNSET ? v2 : initialize(internalThreadLocalMap);
    }

    public V initialValue() {
        return null;
    }

    public final boolean isSet() {
        return isSet(InternalThreadLocalMap.getIfSet());
    }

    public final boolean isSet(InternalThreadLocalMap internalThreadLocalMap) {
        return internalThreadLocalMap != null && internalThreadLocalMap.isIndexedVariableSet(this.index);
    }

    public void onRemoval(V v2) {
    }

    public final void remove() {
        remove(InternalThreadLocalMap.getIfSet());
    }

    /* JADX WARN: Multi-variable type inference failed */
    public final void remove(InternalThreadLocalMap internalThreadLocalMap) {
        if (internalThreadLocalMap == null) {
            return;
        }
        Object objRemoveIndexedVariable = internalThreadLocalMap.removeIndexedVariable(this.index);
        removeFromVariablesToRemove(internalThreadLocalMap, this);
        if (objRemoveIndexedVariable != InternalThreadLocalMap.UNSET) {
            try {
                onRemoval(objRemoveIndexedVariable);
            } catch (Exception e2) {
                PlatformDependent.throwException(e2);
            }
        }
    }

    public final void set(InternalThreadLocalMap internalThreadLocalMap, V v2) {
        if (v2 != InternalThreadLocalMap.UNSET) {
            setKnownNotUnset(internalThreadLocalMap, v2);
        } else {
            remove(internalThreadLocalMap);
        }
    }

    public final void set(V v2) {
        if (v2 == InternalThreadLocalMap.UNSET) {
            remove();
            return;
        }
        InternalThreadLocalMap internalThreadLocalMap = InternalThreadLocalMap.get();
        if (setKnownNotUnset(internalThreadLocalMap, v2)) {
            registerCleaner(internalThreadLocalMap);
        }
    }
}