简单优化过的线程池，目前用在Android上，并发执行2000个耗时任务毫无压力

复制进工程里面就能使用，包名记得填写才行

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * Create by Sage Luo
 * on 2020/11/30 0030 11:41
 */
public class CustomThreadPool {

	//参数初始化
	private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
	//核心线程数量大小
	private static final int corePoolSize = Math.max(2, Math.min(CPU_COUNT - 1, 4));
	//线程池最大容纳线程数
	private static final int maximumPoolSize = CPU_COUNT * 2 + 1;
	//        private static final int maximumPoolSize = 2000;
	//线程空闲后的存活时长
	private static final int keepAliveTime = 30;

	//任务过多后，存储任务的一个阻塞队列
	private final static LinkedBlockingQueue<Runnable> workQueue2 = new LinkedBlockingQueue<>(100);
	private static boolean isFirst = true;

	public static ThreadPoolExecutor get() {
		if (isFirst) {
			mExecute.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
			isFirst = false;
		}
		return mExecute;
	}

	//线程的创建工厂
	private final static ThreadFactory threadFactory = new ThreadFactory() {
		private final AtomicInteger mCount = new AtomicInteger(1);

		public Thread newThread(Runnable r) {
			return new Thread(r, "CTP #" + mCount.getAndIncrement());
		}
	};

	//线程池任务满载后采取的任务拒绝策略
	private final static RejectedExecutionHandler rejectHandler = new ThreadPoolExecutor.DiscardOldestPolicy();

	//线程池对象，创建线程
	private final static ThreadPoolExecutor mExecute = new ThreadPoolExecutor(
			corePoolSize,
			maximumPoolSize,
			keepAliveTime,
			TimeUnit.SECONDS,
			workQueue2,
			threadFactory,
			rejectHandler
	);
}