翰林优商.apk(点击下载) / ChromeThreadPoolExecutor.java


package aegon.chrome.base.task;

import aegon.chrome.base.BuildConfig;
import aegon.chrome.base.task.AsyncTask;
import android.os.Process;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
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;

class ChromeThreadPoolExecutor extends ThreadPoolExecutor {
    private static final int CORE_POOL_SIZE;
    private static final int CPU_COUNT;
    private static final int KEEP_ALIVE_SECONDS;
    private static final int MAXIMUM_POOL_SIZE;
    private static final int RUNNABLE_WARNING_COUNT;
    private static final BlockingQueue<Runnable> sPoolWorkQueue = new ArrayBlockingQueue(128);
    private static final ThreadFactory sThreadFactory = new ThreadFactory() {
        /* class aegon.chrome.base.task.ChromeThreadPoolExecutor.AnonymousClass1 */
        private final AtomicInteger mCount = new AtomicInteger(1);

        static /* synthetic */ void lambda$newThread$0(Runnable runnable) {
            Process.setThreadPriority(10);
            runnable.run();
        }

        public Thread newThread(Runnable runnable) {
            Runnable lambdaFactory$ = ChromeThreadPoolExecutor$1$$Lambda$1.lambdaFactory$(runnable);
            return new Thread(lambdaFactory$, "CrAsyncTask #" + this.mCount.getAndIncrement());
        }
    };

    static {
        int availableProcessors = Runtime.getRuntime().availableProcessors();
        CPU_COUNT = availableProcessors;
        CORE_POOL_SIZE = Math.max(2, Math.min(availableProcessors - 1, 4));
        MAXIMUM_POOL_SIZE = (availableProcessors * 2) + 1;
    }

    ChromeThreadPoolExecutor() {
        this(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, 30, TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);
    }

    ChromeThreadPoolExecutor(int i, int i2, long j, TimeUnit timeUnit, BlockingQueue<Runnable> blockingQueue, ThreadFactory threadFactory) {
        super(i, i2, j, timeUnit, blockingQueue, threadFactory);
        allowCoreThreadTimeOut(true);
    }

    private String findClassNamesWithTooManyRunnables(Map<String, Integer> map) {
        StringBuilder sb = new StringBuilder();
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            if (entry.getValue().intValue() > 32) {
                sb.append(entry.getKey());
                sb.append(' ');
            }
        }
        return sb.length() == 0 ? "NO CLASSES FOUND" : sb.toString();
    }

    private static String getClassName(Runnable runnable) {
        Class cls = runnable.getClass();
        if (cls == AsyncTask.NamedFutureTask.class) {
            try {
                cls = ((AsyncTask.NamedFutureTask) runnable).getBlamedClass();
            } catch (NoSuchFieldException e) {
                if (BuildConfig.DCHECK_IS_ON) {
                    throw new RuntimeException(e);
                }
            } catch (IllegalAccessException e2) {
                if (BuildConfig.DCHECK_IS_ON) {
                    throw new RuntimeException(e2);
                }
            }
        } else if (cls.getEnclosingClass() == android.os.AsyncTask.class) {
            Field declaredField = cls.getDeclaredField("this$0");
            declaredField.setAccessible(true);
            cls = declaredField.get(runnable).getClass();
        }
        return cls.getName();
    }

    private Map<String, Integer> getNumberOfClassNameOccurrencesInQueue() {
        HashMap hashMap = new HashMap();
        for (Runnable runnable : (Runnable[]) getQueue().toArray(new Runnable[0])) {
            String className = getClassName(runnable);
            hashMap.put(className, Integer.valueOf((hashMap.containsKey(className) ? ((Integer) hashMap.get(className)).intValue() : 0) + 1));
        }
        return hashMap;
    }

    public void execute(Runnable runnable) {
        try {
            super.execute(runnable);
        } catch (RejectedExecutionException e) {
            Map<String, Integer> numberOfClassNameOccurrencesInQueue = getNumberOfClassNameOccurrencesInQueue();
            throw new RejectedExecutionException("Prominent classes in AsyncTask: " + findClassNamesWithTooManyRunnables(numberOfClassNameOccurrencesInQueue), e);
        }
    }
}