������������������.apk分析 / v.java

package com.baidu.techain.i;

import android.content.Context;
import android.os.Build;
import android.util.Base64;
import com.baidu.techain.b;
import com.meizu.cloud.pushsdk.constants.PushConstants;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

/* compiled from: ThreadPoolManager */
public class v {
    private static final int a;
    private static volatile v d;
    private static final int e;
    private static long h = 0;
    private ThreadPoolExecutor b;
    private ThreadPoolExecutor c;
    private BlockingQueue<Runnable> f = new LinkedBlockingQueue(100);
    private BlockingQueue<Runnable> g = new LinkedBlockingQueue(10);
    private Context i;

    static {
        int availableProcessors = Runtime.getRuntime().availableProcessors();
        a = availableProcessors;
        e = (availableProcessors * 2) + 1;
    }

    private v(Context context) {
        int i2;
        int max = (context == null || (i2 = com.baidu.techain.h.a.a(context).a.getInt("s_t_p_c_s", -1)) <= 0) ? Math.max(4, a) : i2;
        this.b = new ThreadPoolExecutor(max, Math.max(max, (a * 2) + 1), 10, TimeUnit.SECONDS, this.f, new a("techain_pool_thread_", 5), new ThreadPoolExecutor.AbortPolicy());
        this.c = new ThreadPoolExecutor(2, e, 10, TimeUnit.SECONDS, this.g, new a("techain_pool_core_thread_", 6), new ThreadPoolExecutor.DiscardOldestPolicy());
        if (Build.VERSION.SDK_INT >= 9) {
            this.b.allowCoreThreadTimeOut(true);
            this.c.allowCoreThreadTimeOut(true);
        }
    }

    public final int a(Runnable runnable) {
        try {
            if (this.b == null) {
                return -2;
            }
            this.b.execute(runnable);
            return 1;
        } catch (RejectedExecutionException e2) {
            if (this.i != null) {
                if (System.currentTimeMillis() - h >= 86400000) {
                    HashMap hashMap = new HashMap();
                    hashMap.put(PushConstants.PUSH_TYPE_NOTIFY, Integer.valueOf(a));
                    hashMap.put("1", Integer.valueOf(this.b.getCorePoolSize()));
                    hashMap.put(PushConstants.PUSH_TYPE_UPLOAD_LOG, Integer.valueOf(this.b.getMaximumPoolSize()));
                    hashMap.put(PushConstants.PUSH_FLYME_3_CHANGE_VERSION_START, Base64.encodeToString(b.a(e2).getBytes(), 0).replace("\n", "").replace("\t", "").replace("\r", ""));
                    c.a(this.i.getApplicationContext(), "1003147", (Map<String, Object>) hashMap, true);
                    h = System.currentTimeMillis();
                }
            }
        } catch (Throwable unused) {
            c.a();
        }
        c.a();
        return -1;
    }

    public final int b(Runnable runnable) {
        if (runnable == null) {
            return -2;
        }
        try {
            if (this.c == null) {
                return -2;
            }
            this.c.execute(runnable);
            return 1;
        } catch (Throwable unused) {
            c.a();
            return -3;
        }
    }

    public static v a(Context context) {
        if (d == null) {
            try {
                synchronized (v.class) {
                    if (d == null) {
                        d = new v(context);
                    }
                }
            } catch (Throwable unused) {
                c.a();
            }
        }
        if (!(d == null || d.i != null || context == null)) {
            d.i = context;
        }
        return d;
    }

    /* compiled from: ThreadPoolManager */
    private static class a implements ThreadFactory {
        private final AtomicInteger a = new AtomicInteger(1);
        private final String b;
        private final int c;

        a(String str, int i) {
            this.b = str;
            this.c = i;
        }

        public final Thread newThread(Runnable runnable) {
            Thread thread = new Thread(runnable, this.b + this.a.getAndIncrement());
            if (thread.isDaemon()) {
                thread.setDaemon(false);
            }
            thread.setPriority(this.c);
            return thread;
        }
    }
}