直接列出代码，如下所示：
public final class PoolThread implements Executor{
//省略部分代码……
public static class ThreadBuilder {
final static int TYPE_CACHE = 0;
final static int TYPE_FIXED = 1;
final static int TYPE_SINGLE = 2;
final static int TYPE_SCHEDULED = 3;
int type;
int size;
int priority = Thread.NORM_PRIORITY;
String name;
ThreadCallback callback;
Executor deliver;
ExecutorService pool;
private ThreadBuilder(int size, int type, ExecutorService pool) {
this.size = Math.max(1, size);
this.type = type;
this.pool = pool;
}
/**
* 通过Executors.newSingleThreadExecutor()创建线程池
* 内部只有一个核心线程，所有任务进来都要排队按顺序执行
*/
public static ThreadBuilder create(ExecutorService pool) {
return new ThreadBuilder(1, TYPE_SINGLE, pool);
}
/**
* 通过Executors.newCachedThreadPool()创建线程池
* 它是一个数量无限多的线程池，都是非核心线程，适合执行大量耗时小的任务
*/
public static ThreadBuilder createCacheable() {
return new ThreadBuilder(0, TYPE_CACHE, null);
}
/**
* 通过Executors.newFixedThreadPool()创建线程池
* 线程数量固定的线程池，全部为核心线程，响应较快，不用担心线程会被回收。
*/
public static ThreadBuilder createFixed(int size) {
return new ThreadBuilder(size, TYPE_FIXED, null);
}
/**
* 通过Executors.newScheduledThreadPool()创建线程池
* 有数量固定的核心线程，且有数量无限多的非核心线程，适合用于执行定时任务和固定周期的重复任务
*/
public static ThreadBuilder createScheduled(int size) {
return new ThreadBuilder(size, TYPE_SCHEDULED, null);
}
/**
* 通过Executors.newSingleThreadPool()创建线程池
* 内部只有一个核心线程，所有任务进来都要排队按顺序执行
* 和create区别是size数量
*/
public static ThreadBuilder createSingle() {
return new ThreadBuilder(0, TYPE_SINGLE, null);
}
/**
* 将默认线程名设置为“已使用”。
*/
public ThreadBuilder setName (@NonNull String name) {
if (name.length()>0) {
this.name = name;
}
return this;
}
/**
* 将默认线程优先级设置为“已使用”。
*/
public ThreadBuilder setPriority (int priority) {
this.priority = priority;
return this;
}
/**
* 将默认线程回调设置为“已使用”。
*/
public ThreadBuilder setCallback (ThreadCallback callback) {
this.callback = callback;
return this;
}
/**
* 设置默认线程交付使用
*/
public ThreadBuilder setDeliver(Executor deliver) {
this.deliver = deliver;
return this;
}
/**
* 创建用于某些配置的线程管理器。
* @return 对象
*/
public PoolThread build () {
//最大值
priority = Math.max(Thread.MIN_PRIORITY, priority);
//最小值
priority = Math.min(Thread.MAX_PRIORITY, priority);
size = Math.max(1, size);
if (name==null || name.length()==0) {
// 如果没有设置名字，那么就使用下面默认的线程名称
switch (type) {
case TYPE_CACHE:
name = "CACHE";
break;
case TYPE_FIXED:
name = "FIXED";
break;
case TYPE_SINGLE:
name = "SINGLE";
break;
default:
name = "POOL_THREAD";
break;
}
}
if (deliver == null) {
if (ThreadToolUtils.isAndroid) {
deliver = AndroidDeliver.getInstance();
} else {
deliver = JavaDeliver.getInstance();
}
}
return new PoolThread(type, size, priority, name, callback, deliver, pool);
}
}
}
