翰林优商.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);
}
}
}