package io.netty.util.concurrent;

import g.a.a.a.a;
import io.netty.util.internal.StringUtil;
import java.util.Locale;
import java.util.Objects;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;

/* JADX INFO: loaded from: classes.dex */
public class DefaultThreadFactory implements ThreadFactory {
    private static final AtomicInteger poolId = new AtomicInteger();
    private final boolean daemon;
    private final AtomicInteger nextId;
    private final String prefix;
    private final int priority;
    public final ThreadGroup threadGroup;

    public DefaultThreadFactory(Class<?> cls) {
        this(cls, false, 5);
    }

    public DefaultThreadFactory(Class<?> cls, int i2) {
        this(cls, false, i2);
    }

    public DefaultThreadFactory(Class<?> cls, boolean z2) {
        this(cls, z2, 5);
    }

    public DefaultThreadFactory(Class<?> cls, boolean z2, int i2) {
        this(toPoolName(cls), z2, i2);
    }

    public DefaultThreadFactory(String str) {
        this(str, false, 5);
    }

    public DefaultThreadFactory(String str, int i2) {
        this(str, false, i2);
    }

    public DefaultThreadFactory(String str, boolean z2) {
        this(str, z2, 5);
    }

    public DefaultThreadFactory(String str, boolean z2, int i2) {
        this(str, z2, i2, System.getSecurityManager() == null ? Thread.currentThread().getThreadGroup() : System.getSecurityManager().getThreadGroup());
    }

    public DefaultThreadFactory(String str, boolean z2, int i2, ThreadGroup threadGroup) {
        this.nextId = new AtomicInteger();
        Objects.requireNonNull(str, "poolName");
        if (i2 < 1 || i2 > 10) {
            throw new IllegalArgumentException(a.n("priority: ", i2, " (expected: Thread.MIN_PRIORITY <= priority <= Thread.MAX_PRIORITY)"));
        }
        this.prefix = str + '-' + poolId.incrementAndGet() + '-';
        this.daemon = z2;
        this.priority = i2;
        this.threadGroup = threadGroup;
    }

    public static String toPoolName(Class<?> cls) {
        Objects.requireNonNull(cls, "poolType");
        String strSimpleClassName = StringUtil.simpleClassName(cls);
        int length = strSimpleClassName.length();
        if (length == 0) {
            return "unknown";
        }
        if (length == 1) {
            return strSimpleClassName.toLowerCase(Locale.US);
        }
        if (!Character.isUpperCase(strSimpleClassName.charAt(0)) || !Character.isLowerCase(strSimpleClassName.charAt(1))) {
            return strSimpleClassName;
        }
        return Character.toLowerCase(strSimpleClassName.charAt(0)) + strSimpleClassName.substring(1);
    }

    @Override // java.util.concurrent.ThreadFactory
    public Thread newThread(Runnable runnable) {
        Thread threadNewThread = newThread(FastThreadLocalRunnable.wrap(runnable), this.prefix + this.nextId.incrementAndGet());
        try {
            boolean zIsDaemon = threadNewThread.isDaemon();
            boolean z2 = this.daemon;
            if (zIsDaemon != z2) {
                threadNewThread.setDaemon(z2);
            }
            int priority = threadNewThread.getPriority();
            int i2 = this.priority;
            if (priority != i2) {
                threadNewThread.setPriority(i2);
            }
        } catch (Exception unused) {
        }
        return threadNewThread;
    }

    public Thread newThread(Runnable runnable, String str) {
        return new FastThreadLocalThread(this.threadGroup, runnable, str);
    }
}