本篇内容为译文，翻译过来一起学习，一起进步 。
ThreadPool图解.png
下面将会介绍线程池、线程池使用方法以及在Android中如何使用。
ThreadPools
一个线程池管理一个工作线程池（具体的线程数量取决于它的实现方式）。
任务队列包含在线程池中任何一个空闲线程执行的任务。任务由生产者添加到队列中，工作线程充当消费者，只要有一个空闲线程准备好，就会消耗队列中的任务。
ThreadPoolExecutor
ThreadPoolExecutor来管理线程池中的线程。
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue
);
参数介绍
① corePoolSize：池中保留最小的线程数。最初池中是零个线程，但是随着任务被添加到队列中，新的线程被创建。如果有空闲线程，但是线程数是小于corePoolSize，那么新线程将会继续被创建。
② maximumPoolSize：池中允许的最大线程数。如果超过了corePoolSize，并且当前线程数大于等于corePoolSize，那么只有当队列已满时，才会创建新的线程。
③ keepAliveTime：当线程数大于核心线程数时，非核心线程（空闲线程）将等待新的任务。如果在这个时间内没有得到一个新的线程，那么它们将终止。
④ unit：keepAliveTime的时间单位。
⑤ workQueue：任务队列。它将只保存可运行的任务，这是一个BlockingQueue。
为什么要在Android或者Java使用线程池？
① 这是一个强大的任务执行框架，它支持向队列中添加任务、取消任务、任务优先级。
② 它减少了线程创建时的开销。因为它在线程池中管理所需的线程数量。
在Android中使用ThreadPoolExecutor
首先创建一个PriorityThreadFactory：
public class PriorityThreadFactory implements ThreadFactory {
private final int mThreadPriority;
public PriorityThreadFactory(int threadPriority) {
mThreadPriority = threadPriority;
}
@Override
public Thread newThread(final Runnable runnable) {
Runnable wrapperRunnable = new Runnable() {
@Override
public void run() {
try {
Process.setThreadPriority(mThreadPriority);
} catch (Throwable t) {
}
runnable.run();
}
};
return new Thread(wrapperRunnable);
}
}
创建一个MainThreadExecutor：
public class MainThreadExecutor implements Executor {
private final Handler handler = new Handler(Looper.getMainLooper());
@Override
public void execute(Runnable runnable) {
handler.post(runnable);
}
}
创建一个DefaultExecutorSupplier：
/*
* 单例的Executor
*/
public class DefaultExecutorSupplier{
/*
* 核心线程数量
*/
public static final int NUMBER_OF_CORES = Runtime.getRuntime().availableProcessors();
/*
* 线程池执行后台任务
*/
private final ThreadPoolExecutor mForBackgroundTasks;
/*
* 线程池执行轻微的后台任务
*/
private final ThreadPoolExecutor mForLightWeightBackgroundTasks;
/*
* 线程池执行主线程任务
*/
private final Executor mMainThreadExecutor;
/*
* DefaultExecutorSupplier的一个实例
*/
private static DefaultExecutorSupplier sInstance;
/*
* 返回DefaultExecutorSupplier的实例
*/
public static DefaultExecutorSupplier getInstance() {
if (sInstance == null) {
synchronized(DefaultExecutorSupplier.class){
sInstance = new DefaultExecutorSupplier();
}
return sInstance;
}
/*
* DefaultExecutorSupplier的构造函数
*/
private DefaultExecutorSupplier() {
// 设置 thread factory
ThreadFactory backgroundPriorityThreadFactory = new
PriorityThreadFactory(Process.THREAD_PRIORITY_BACKGROUND);
// 设置mForBackgroundTasks的线程池执行器;
mForBackgroundTasks = new ThreadPoolExecutor(
NUMBER_OF_CORES * 2,
NUMBER_OF_CORES * 2,
60L,
TimeUnit.SECONDS,
new LinkedBlockingQueue<Runnable>(),
backgroundPriorityThreadFactory
);
// 为mForLightWeightBackgroundTasks设置线程池执行器;
mForLightWeightBackgroundTasks = new ThreadPoolExecutor(
NUMBER_OF_CORES * 2,
NUMBER_OF_CORES * 2,
60L,
TimeUnit.SECONDS,
new LinkedBlockingQueue<Runnable>(),
backgroundPriorityThreadFactory
);
//设置mMainThreadExecutor的线程池执行器;
mMainThreadExecutor = new MainThreadExecutor();
}
/*
* 返回线程池中的后台任务
*/
public ThreadPoolExecutor forBackgroundTasks() {
return mForBackgroundTasks;
}
/*
* 返回线程池中的轻微后台任务
*/
public ThreadPoolExecutor forLightWeightBackgroundTasks() {
return mForLightWeightBackgroundTasks;
}
/*
* 返回线程池中主线程任务
*/
public Executor forMainThreadTasks() {
return mMainThreadExecutor;
}
}
注意：线程池中的具体线程数量取决您的具体业务场景。
下面您可以在代码中使用它了：
/*
* 执行后台任务
*/
public void doSomeBackgroundWork(){
DefaultExecutorSupplier.getInstance().forBackgroundTasks()
.execute(new Runnable() {
@Override
public void run() {
// some code...
}
});
}
/*
* 执行轻微的后台任务
*/
public void doSomeLightWeightBackgroundWork(){
DefaultExecutorSupplier.getInstance().forLightWeightBackgroundTasks()
.execute(new Runnable() {
@Override
public void run() {
// some code...
}
});
}
/*
* 执行主线程任务
*/
public void doSomeMainThreadWork(){
DefaultExecutorSupplier.getInstance().forMainThreadTasks()
.execute(new Runnable() {
@Override
public void run() {
// some code...
}
});
}
这样，咱们就可以为网络任务、IO任务、后台任务和其他任务创建一个不同的线程池。
该如何取消任务？
要取消任务，您必须得到这个任务的future。这里我们需要使用submit代替execute来返回一个future。这个future可以被用来取消任务。
/*
* 通过submit提交到线程池中来获取future
*/
Future future = DefaultExecutorSupplier.getInstance().forBackgroundTasks()
.submit(new Runnable() {
@Override
public void run() {
// do some background work here.
}
});
/*
* 取消任务
*/
future.cancel(true);
如何设置任务的优先级？
假设队列中有10个任务，线程池中只有4个线程。这时我们需要根据优先级来执行任务，因为池中只能执行4个任务。这时我们为队列中的最后一个线程设置IMMEDIATE优先级，当线程从队列中取任务时，就会先执行该任务（因为它的优先级高）。
要设置任务的优先级，需要先创建thread pool executor。
创建优先级的ENUM：
/**
* 优先级
*/
public enum Priority {
/**
* 最低优先级。用于预取数据
*/
LOW,
/**
* 中等优先级。用于预热可能很快可见的数据
*/
MEDIUM,
/**
* 最高优先级。用于屏幕上当前可见的数据
*/
HIGH,
/**
* 最高优先级。用于即时需要的数据（主要用于紧急情况）。
*/
IMMEDIATE;
}
创建一个PriorityRunnable：
public class PriorityRunnable implements Runnable {
private final Priority priority;
public PriorityRunnable(Priority priority) {
this.priority = priority;
}
@Override
public void run() {
// nothing to do here.
}
public Priority getPriority() {
return priority;
}
}
创建一个扩展ThreadPoolExecutor的PriorityThreadPoolExecutor。我们必须创建PriorityFutureTask，它将实现Comparable <PriorityFutureTask>：
public class PriorityThreadPoolExecutor extends ThreadPoolExecutor {
public PriorityThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime,
TimeUnit unit, ThreadFactory threadFactory) {
super(corePoolSize, maximumPoolSize, keepAliveTime, unit,new PriorityBlockingQueue<Runnable>(), threadFactory);
}
@Override
public Future<?> submit(Runnable task) {
PriorityFutureTask futureTask = new PriorityFutureTask((PriorityRunnable) task);
execute(futureTask);
return futureTask;
}
private static final class PriorityFutureTask extends FutureTask<PriorityRunnable>
implements Comparable<PriorityFutureTask> {
private final PriorityRunnable priorityRunnable;
public PriorityFutureTask(PriorityRunnable priorityRunnable) {
super(priorityRunnable, null);
this.priorityRunnable = priorityRunnable;
}
@Override
public int compareTo(PriorityFutureTask other) {
Priority p1 = priorityRunnable.getPriority();
Priority p2 = other.priorityRunnable.getPriority();
return p2.ordinal() - p1.ordinal();
}
}
}
首先，在DefaultExecutorSupplier中，而不是ThreadPoolExecutor，像这样使用PriorityThreadPoolExecutor：
public class DefaultExecutorSupplier{
private final PriorityThreadPoolExecutor mForBackgroundTasks;
private DefaultExecutorSupplier() {
mForBackgroundTasks = new PriorityThreadPoolExecutor(
NUMBER_OF_CORES * 2,
NUMBER_OF_CORES * 2,
60L,
TimeUnit.SECONDS,
backgroundPriorityThreadFactory
);
}
}
下面是如何为任务添加高优先级示例：
public void doSomeTaskAtHighPriority(){
DefaultExecutorSupplier.getInstance().forBackgroundTasks()
.submit(new PriorityRunnable(Priority.HIGH) {
@Override
public void run() {
// some code...
}
});
}
通过上面方式，任务将会被考虑优先执行。
上面的实现方式也适用于JAVA应用程序
