/**
* OpenAtlasForAndroid Project
* The MIT License (MIT) Copyright (OpenAtlasForAndroid) 2015 Bunny Blue,achellies
* <p>
* Permission is hereby granted, free of charge, to any person obtaining a copy of this software
* and associated documentation files (the "Software"), to deal in the Software
* without restriction, including without limitation the rights to use, copy, modify,
* merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to the following conditions:
* <p>
* The above copyright notice and this permission notice shall be included in all copies
* or substantial portions of the Software.
* <p>
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
* PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
* FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
* @author BunnyBlue
**/
package com.openatlas.android.task;
import android.os.AsyncTask;
import android.os.Build.VERSION;
import java.io.File;
import java.io.FileFilter;
import java.lang.Thread.State;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.HashSet;
import java.util.Iterator;
import java.util.concurrent.Executor;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.LockSupport;
import java.util.regex.Pattern;
public class SaturativeExecutor extends ThreadPoolExecutor {
private static final boolean DEBUG = false;
static final Pattern PATTERN_CPU_ENTRIES;
static final String TAG = "SatuExec";
private static SaturationAwareBlockingQueue<Runnable> mQueue;
private static final HashSet<Thread> mThreads;
private static final ThreadFactory sThreadFactory;
protected static class CountedTask implements Runnable {
static final AtomicInteger mNumRunning;
Runnable mRunnable;
public CountedTask(Runnable runnable) {
this.mRunnable = runnable;
}
@Override
public void run() {
mNumRunning.incrementAndGet();
try {
this.mRunnable.run();
} finally {
mNumRunning.decrementAndGet();
}
}
static {
mNumRunning = new AtomicInteger();
}
}
protected static class SaturationAwareBlockingQueue<T> extends
LinkedBlockingQueue<T> {
private static final long serialVersionUID = 1;
private SaturativeExecutor mExecutor;
public SaturationAwareBlockingQueue(int i) {
super(i);
}
void setExecutor(SaturativeExecutor saturativeExecutor) {
this.mExecutor = saturativeExecutor;
}
@Override
public boolean add(T t) {
if (!this.mExecutor.isReallyUnsaturated()) {
return super.add(t);
}
throw new IllegalStateException("Unsaturated");
}
@Override
public boolean offer(T t) {
return this.mExecutor.isReallyUnsaturated() ? DEBUG : super
.offer(t);
}
@Override
public void put(T t) {
throw new UnsupportedOperationException();
}
@Override
public boolean offer(T t, long j, TimeUnit timeUnit) {
throw new UnsupportedOperationException();
}
}
static {
PATTERN_CPU_ENTRIES = Pattern.compile("cpu[0-9]+");
sThreadFactory = new ThreadFactory() {
private final AtomicInteger a = new AtomicInteger(1);
@Override
public Thread newThread(Runnable runnable) {
Thread thread = new Thread(runnable, "SaturativeThread #"
+ this.a.getAndIncrement());
SaturativeExecutor.collectThread(thread);
return thread;
}
};
mThreads = new HashSet<Thread>();
}
@Override
public void execute(Runnable runnable) {
super.execute(new CountedTask(runnable));
}
public static final boolean installAsDefaultAsyncTaskExecutor(
ThreadPoolExecutor threadPoolExecutor) {
if (VERSION.SDK_INT >= 11) {
try {
Field declaredField = AsyncTask.class
.getDeclaredField("THREAD_POOL_EXECUTOR");
declaredField.setAccessible(true);
declaredField.set(null, threadPoolExecutor);
} catch (Exception e) {
}
}
try {
Method method = AsyncTask.class.getMethod("setDefaultExecutor",
Executor.class);
method.setAccessible(true);
method.invoke(null, threadPoolExecutor);
return true;
} catch (Exception e2) {
Field declaredField;
try {
declaredField = AsyncTask.class
.getDeclaredField("sDefaultExecutor");
declaredField.setAccessible(true);
declaredField.set(null, threadPoolExecutor);
return true;
} catch (Exception e3) {
try {
declaredField = AsyncTask.class
.getDeclaredField("sExecutor");
declaredField.setAccessible(true);
declaredField.set(null, threadPoolExecutor);
return true;
} catch (Exception e4) {
return false;
}
}
}
}
public SaturativeExecutor() {
this(determineBestMinPoolSize());
}
public SaturativeExecutor(int corePoolSize) {
super(corePoolSize, 128, 1, TimeUnit.SECONDS, new SaturationAwareBlockingQueue(
1024), sThreadFactory, new CallerRunsPolicy());
// BlockingQueue saturationAwareBlockingQueue = new
// SaturationAwareBlockingQueue(1024);
// mQueue = saturationAwareBlockingQueue;
mQueue = (SaturationAwareBlockingQueue<Runnable>) getQueue();
((SaturationAwareBlockingQueue<?>) getQueue()).setExecutor(this);
}
protected boolean isReallyUnsaturated() {
if (isSaturated()) {
return DEBUG;
}
LockSupport.parkNanos(10);
return !isSaturated() ? true : DEBUG;
}
protected boolean isSaturated() {
if (getPoolSize() <= 3) {
return DEBUG;
}
int corePoolSize = getCorePoolSize();
int i = CountedTask.mNumRunning.get();
int size = mThreads.size();
if (i < corePoolSize || i < size) {
return true;
}
boolean z;
synchronized (mThreads) {
Iterator<Thread> it = mThreads.iterator();
size = 0;
while (it.hasNext()) {
State state = it.next().getState();
if (state == State.RUNNABLE || state == State.NEW) {
i = size + 1;
} else {
if (state == State.TERMINATED) {
it.remove();
}
i = size;
}
size = i;
}
}
z = size >= corePoolSize;
return z;
}
public static void collectThread(Thread thread) {
synchronized (mThreads) {
mThreads.add(thread);
}
}
private static int determineBestMinPoolSize() {
int countCpuCores = countCpuCores();
return countCpuCores > 0 ? countCpuCores : Runtime.getRuntime()
.availableProcessors() * 2;
}
private static int countCpuCores() {
try {
return new File("/sys/devices/system/cpu/").listFiles(new FileFilter() {
@Override
public boolean accept(File file) {
return SaturativeExecutor.PATTERN_CPU_ENTRIES.matcher(file.getName())
.matches();
}
}).length;
} catch (Exception e) {
return 0;
}
}
}
