最近接触到了阿里的Android studio 的一个插件 aliCheck,一扫描尽然大几千个ERR，就连前面使用的lib 库里面也是大片爆红。
下面简单说下线程池的创建和使用:
*线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，这样的处理方式让写的同学更加明确线程池的运行规则，
规避资源耗尽的风险。 说明：Executors各个方法的弊端：
1）newFixedThreadPool和newSingleThreadExecutor:
主要问题是堆积的请求处理队列可能会耗费非常大的内存，甚至OOM。（队列任务可能超过1000 甚至n）
2）newCachedThreadPool和newScheduledThreadPool:
主要问题是线程数最大数是Integer.MAX_VALUE，可能会创建数量非常多的线程，甚至OOM。
那么怎样创建？
下面给出一个简单的栗子：
class BasicThreadFactory implements ThreadFactory {
private AtomicLong mThreadCounter;
/**
* 包装工厂
*/
private ThreadFactory mThreadFactory;
/**
* 非捕获异常处理器
*/
private Thread.UncaughtExceptionHandler mExceptionHandler;
/**
* 命名模式
*/
private String mNamingPattern;
/**
* 优先级
*/
private Integer mPriority;
/**
* 后台状态标识
*/
private Boolean mDaemonFlag;
public BasicThreadFactory(ThreadBuilder threadBuilder) {
if (threadBuilder instanceof DefaultThreadBuilder) {
DefaultThreadBuilder builder = (DefaultThreadBuilder) threadBuilder;
if (builder.mThreadFactory == null) {
mThreadFactory = Executors.defaultThreadFactory();
} else {
mThreadFactory = builder.mThreadFactory;
}
mNamingPattern = builder.mNamingPattern;
mDaemonFlag = builder.mDaemonFlag;
mExceptionHandler = builder.mExceptionHandler;
mPriority = builder.mPriority;
mThreadCounter = new AtomicLong();
}
}
@Override
public Thread newThread(@NonNull Runnable runnable) {
Thread thread = getWrappedFactory().newThread(runnable);
initThread(thread);
return thread;
}
private void initThread(Thread thread) {
if (getNamingPattern() != null) {
Long count = mThreadCounter.incrementAndGet();
thread.setName(String.format(getNamingPattern(), count));
}
if (getUncaughtExceptionHandler() != null) {
thread.setUncaughtExceptionHandler(getUncaughtExceptionHandler());
}
if (getPriority() != null) {
thread.setPriority(getPriority());
}
if (getDaemonFlag() != null) {
thread.setDaemon(getDaemonFlag());
}
}
/**
* 获取包装工厂
*
* @return 不会返回null
*/
public final ThreadFactory getWrappedFactory() {
return mThreadFactory;
}
/**
* 获取命名模式
*
* @return
*/
public final String getNamingPattern() {
return mNamingPattern;
}
/**
* 获取是否为后台线程标识
*
* @return
*/
public final Boolean getDaemonFlag() {
return mDaemonFlag;
}
/**
* 获取优先级
*
* @return
*/
public final Integer getPriority() {
return mPriority;
}
/**
* 获取非捕获异常处理器
*
* @return
*/
public final Thread.UncaughtExceptionHandler getUncaughtExceptionHandler() {
return mExceptionHandler;
}
/**
* 获取创建的线程数量
*
* @return
*/
public long getThreadCount() {
return mThreadCounter.get();
}
public static final class DefaultThreadBuilder implements ThreadBuilder<BasicThreadFactory> {
/**
* 包装工厂
*/
private ThreadFactory mThreadFactory;
/**
* 非捕获异常处理器
*/
private Thread.UncaughtExceptionHandler mExceptionHandler;
/**
* 命名模式
*/
private String mNamingPattern;
/**
* 优先级
*/
private Integer mPriority;
/**
* 后台状态标识
*/
private Boolean mDaemonFlag;
@Override
public BasicThreadFactory build() {
BasicThreadFactory basicThreadFactory = new BasicThreadFactory(this);
reset();
return basicThreadFactory;
}
/**
* 创建包装工厂
*/
public DefaultThreadBuilder wrappedFactory(ThreadFactory threadFactory) {
if (threadFactory == null) {
throw new NullPointerException("wrappedFactory can not to be null !");
}
mThreadFactory = threadFactory;
return this;
}
/**
* 设置命名模式
*/
public DefaultThreadBuilder namingPattern(String namingPattern) {
if (namingPattern == null) {
throw new NullPointerException("namingPattern can not to be null !");
}
mNamingPattern = namingPattern;
return this;
}
/**
* 设置非捕获异常处理
*/
public DefaultThreadBuilder uncaughtExceptionHandler(Thread.UncaughtExceptionHandler uncaughtExceptionHandler) {
if (uncaughtExceptionHandler == null) {
throw new NullPointerException("uncaughtExceptionHandler can not to be null !");
}
mExceptionHandler = uncaughtExceptionHandler;
return this;
}
/**
* 设置优先级
*/
public DefaultThreadBuilder priority(int priority) {
mPriority = priority;
return this;
}
/**
* 设置后台标识
*/
public DefaultThreadBuilder daemon(boolean daemonFlag) {
mDaemonFlag = daemonFlag;
return this;
}
/**
* 重置
*/
public void reset() {
mExceptionHandler = null;
mDaemonFlag = null;
mPriority = null;
mNamingPattern = null;
mThreadFactory = null;
}
}
package cn.mugua.com.filepicker.util;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
public class ThreadPoolUtil {
public static final int THREAD_POOL_SCHEDULED = 0;
public static final int THREAD_POOL_NORMAL = 1;
private ThreadPoolUtil() {
throw new UnsupportedOperationException("u can't instantiate me...");
}
private ExecutorService exec;
private ScheduledExecutorService scheduleExec;
/**
* ThreadPoolUtils构造函数
*线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。 说明：Executors各个方法的弊端：
1）newFixedThreadPool和newSingleThreadExecutor:
主要问题是堆积的请求处理队列可能会耗费非常大的内存，甚至OOM。
2）newCachedThreadPool和newScheduledThreadPool:
主要问题是线程数最大数是Integer.MAX_VALUE，可能会创建数量非常多的线程，甚至OOM。
* @param type 线程池类型 0
* @param corePoolSize 只对Fixed和Scheduled线程池起效
*/
public ThreadPoolUtil(int type,int corePoolSize) {
// 构造有定时功能的线程池
scheduleExec = new ScheduledThreadPoolExecutor(corePoolSize,
new BasicThreadFactory.DefaultThreadBuilder().namingPattern("schedule-pool-%d").daemon(true).build());
switch (type) {
case THREAD_POOL_SCHEDULED:
exec = scheduleExec;
break;
case THREAD_POOL_NORMAL:
default:
ThreadFactory namedThreadFactory = new BasicThreadFactory.DefaultThreadBuilder()
.namingPattern("normal-pool-%d").build();
//Common Thread Pool
exec = new ThreadPoolExecutor(corePoolSize, 200,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>(1024), namedThreadFactory, new ThreadPoolExecutor.AbortPolicy());
break;
}
}
/**
* 在未来某个时间执行给定的命令
* <p>该命令可能在新的线程、已入池的线程或者正调用的线程中执行，这由 Executor 实现决定。</p>
*
* @param command 命令
*/
public void execute(Runnable command) {
exec.execute(command);
}
/**
* 在未来某个时间执行给定的命令链表
* <p>该命令可能在新的线程、已入池的线程或者正调用的线程中执行，这由 Executor 实现决定。</p>
*
* @param commands 命令链表
*/
public void execute(List<Runnable> commands) {
for (Runnable command : commands) {
exec.execute(command);
}
}
/**
* 待以前提交的任务执行完毕后关闭线程池
* <p>启动一次顺序关闭，执行以前提交的任务，但不接受新任务。
* 如果已经关闭，则调用没有作用。</p>
*/
public void shutDown() {
exec.shutdown();
}
/**
* 试图停止所有正在执行的活动任务
* <p>试图停止所有正在执行的活动任务，暂停处理正在等待的任务，并返回等待执行的任务列表。</p>
* <p>无法保证能够停止正在处理的活动执行任务，但是会尽力尝试。</p>
*
* @return 等待执行的任务的列表
*/
public List<Runnable> shutDownNow() {
return exec.shutdownNow();
}
/**
* 判断线程池是否已关闭
*
* @return {@code true}: 是<br>{@code false}: 否
*/
public boolean isShutDown() {
return exec.isShutdown();
}
/**
* 关闭线程池后判断所有任务是否都已完成
* <p>注意，除非首先调用 shutdown 或 shutdownNow，否则 isTerminated 永不为 true。</p>
*
* @return {@code true}: 是<br>{@code false}: 否
*/
public boolean isTerminated() {
return exec.isTerminated();
}
/**
* 请求关闭、发生超时或者当前线程中断
* <p>无论哪一个首先发生之后，都将导致阻塞，直到所有任务完成执行。</p>
*
* @param timeout 最长等待时间
* @param unit 时间单位
* @return {@code true}: 请求成功<br>{@code false}: 请求超时
* @throws InterruptedException 终端异常
*/
public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
return exec.awaitTermination(timeout, unit);
}
/**
* 提交一个Callable任务用于执行
* <p>如果想立即阻塞任务的等待，则可以使用{@code result = exec.submit(aCallable).get();}形式的构造。</p>
*
* @param task 任务
* @param <T> 泛型
* @return 表示任务等待完成的Future, 该Future的{@code get}方法在成功完成时将会返回该任务的结果。
*/
public <T> Future<T> submit(Callable<T> task) {
return exec.submit(task);
}
/**
* 提交一个Runnable任务用于执行
*
* @param task 任务
* @param result 返回的结果
* @param <T> 泛型
* @return 表示任务等待完成的Future, 该Future的{@code get}方法在成功完成时将会返回该任务的结果。
*/
public <T> Future<T> submit(Runnable task, T result) {
return exec.submit(task, result);
}
/**
* 提交一个Runnable任务用于执行
*
* @param task 任务
* @return 表示任务等待完成的Future, 该Future的{@code get}方法在成功完成时将会返回null结果。
*/
public Future<?> submit(Runnable task) {
return exec.submit(task);
}
/**
* 执行给定的任务
* <p>当所有任务完成时，返回保持任务状态和结果的Future列表。
* 返回列表的所有元素的{@link Future#isDone}为{@code true}。
* 注意，可以正常地或通过抛出异常来终止已完成任务。
* 如果正在进行此操作时修改了给定的 collection，则此方法的结果是不确定的。</p>
*
* @param tasks 任务集合
* @param <T> 泛型
* @return 表示任务的 Future 列表，列表顺序与给定任务列表的迭代器所生成的顺序相同，每个任务都已完成。
* @throws InterruptedException 如果等待时发生中断，在这种情况下取消尚未完成的任务。
*/
public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException {
return exec.invokeAll(tasks);
}
/**
* 执行给定的任务
* <p>当所有任务完成或超时期满时(无论哪个首先发生)，返回保持任务状态和结果的Future列表。
* 返回列表的所有元素的{@link Future#isDone}为{@code true}。
* 一旦返回后，即取消尚未完成的任务。
* 注意，可以正常地或通过抛出异常来终止已完成任务。
* 如果此操作正在进行时修改了给定的 collection，则此方法的结果是不确定的。</p>
*
* @param tasks 任务集合
* @param timeout 最长等待时间
* @param unit 时间单位
* @param <T> 泛型
* @return 表示任务的 Future 列表，列表顺序与给定任务列表的迭代器所生成的顺序相同。如果操作未超时，则已完成所有任务。如果确实超时了，则某些任务尚未完成。
* @throws InterruptedException 如果等待时发生中断，在这种情况下取消尚未完成的任务
*/
public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws
InterruptedException {
return exec.invokeAll(tasks, timeout, unit);
}
/**
* 执行给定的任务
* <p>如果某个任务已成功完成（也就是未抛出异常），则返回其结果。
* 一旦正常或异常返回后，则取消尚未完成的任务。
* 如果此操作正在进行时修改了给定的collection，则此方法的结果是不确定的。</p>
*
* @param tasks 任务集合
* @param <T> 泛型
* @return 某个任务返回的结果
* @throws InterruptedException 如果等待时发生中断
* @throws ExecutionException 如果没有任务成功完成
*/
public <T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException {
return exec.invokeAny(tasks);
}
/**
* 执行给定的任务
* <p>如果在给定的超时期满前某个任务已成功完成（也就是未抛出异常），则返回其结果。
* 一旦正常或异常返回后，则取消尚未完成的任务。
* 如果此操作正在进行时修改了给定的collection，则此方法的结果是不确定的。</p>
*
* @param tasks 任务集合
* @param timeout 最长等待时间
* @param unit 时间单位
* @param <T> 泛型
* @return 某个任务返回的结果
* @throws InterruptedException 如果等待时发生中断
* @throws ExecutionException 如果没有任务成功完成
* @throws TimeoutException 如果在所有任务成功完成之前给定的超时期满
*/
public <T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws
InterruptedException, ExecutionException, TimeoutException {
return exec.invokeAny(tasks, timeout, unit);
}
/**
* 延迟执行Runnable命令
*
* @param command 命令
* @param delay 延迟时间
* @param unit 单位
* @return 表示挂起任务完成的ScheduledFuture，并且其{@code get()}方法在完成后将返回{@code null}
*/
public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) {
return scheduleExec.schedule(command, delay, unit);
}
/**
* 延迟执行Callable命令
*
* @param callable 命令
* @param delay 延迟时间
* @param unit 时间单位
* @param <V> 泛型
* @return 可用于提取结果或取消的ScheduledFuture
*/
public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit) {
return scheduleExec.schedule(callable, delay, unit);
}
/**
* 延迟并循环执行命令
*
* @param command 命令
* @param initialDelay 首次执行的延迟时间
* @param period 连续执行之间的周期
* @param unit 时间单位
* @return 表示挂起任务完成的ScheduledFuture，并且其{@code get()}方法在取消后将抛出异常
*/
public ScheduledFuture<?> scheduleWithFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) {
return scheduleExec.scheduleAtFixedRate(command, initialDelay, period, unit);
}
/**
* 延迟并以固定休息时间循环执行命令
*
* @param command 命令
* @param initialDelay 首次执行的延迟时间
* @param delay 每一次执行终止和下一次执行开始之间的延迟
* @param unit 时间单位
* @return 表示挂起任务完成的ScheduledFuture，并且其{@code get()}方法在取消后将抛出异常
*/
public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit) {
return scheduleExec.scheduleWithFixedDelay(command, initialDelay, delay, unit);
}
}
最后使用的时候搭配 callable 使用很方便
public Future<List<File>> loadFiles(final String path, final FileFilter fileFilter) { return mThreadPoolUtil.submit(new Callable<List<File>>() { @Override public List<File> call() throws Exception { return FileUtils.listFilesInDirWithFilter(path, fileFilter); } }); }