Android实现高性能，高并发，可延时线程池管理
为什么要使用线程池？
1.）new Thread()的缺点
每次new Thread()耗费性能
调用new Thread()创建的线程缺乏管理，被称为野线程，而且可以无限制创建，之间相互竞争，会导致过多占用系统资源导致系统瘫痪。
不利于扩展，比如如定时执行、定期执行、线程中断
2.）采用线程池的优点
重用存在的线程，减少对象创建、消亡的开销，性能佳
可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞
提供定时执行、定期执行、单线程、并发数控制等功能
线程池相关类的继承关系:
structure.jpg
Executor<--ExecutorService<--AbstractExecutorService<--ThreadPoolExecutor
Executors可以生成快捷的线程池，ThreadPoolExecutor完全自定义线程池
源码ThreadPoolExecutor分析
自定义线程池工具ThreadManager(在本文章后面)
创建了线程代理new ThreadPoolProxy()
作用:替换new Thread()的线程
使用方式:
ThreadManager.getNormalPool().execute(Runnable对象);//普通线程池
ThreadManager.getDownloadPool().execute(Runnable对象);//下载专用线程池
ThreadManager.getXxxxxPool().remove(Runnable对象);//移除任务(停止线程池执行)
使用线程池的好处:
1.降低资源消耗：通过重用已经创建的线程来降低线程创建和销毁的消耗
2.提高响应速度：任务到达时不需要等待线程创建就可以立即执行。
3.提高线程的可管理性：线程池可以统一管理、分配、调优和监控
源码分析:构造方法
public ThreadPoolExecutor(int corePoolSize, //核心线程池大小
int maximumPoolSize,//线程池最大容量大小
long keepAliveTime,//线程池空闲时，线程存活的时间
TimeUnit unit,//时间单位
BlockingQueue<Runnable> workQueue,//任务队列
ThreadFactory threadFactory,//线程工厂
RejectedExecutionHandler handler) //线程拒绝策略{....}
//当前的Worker的数量小于核心线程池大小时，新建一个Worker。
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
(1).corePoolSize:设置一个线程池中的核心线程数
如果设置allowCoreThreadTimeOut为false的情况下：
即使当线程池中的线程处于空闲状态，这些线程也不会被线程池中移除。
如果设置了allowCoreThreadTimeOut为true,
那么当核心线程在空闲了一段时间后依旧没有用于工作，那么将会从线程池中移除。
注意:(allowCoreThreadTimeOut默认为false，通常情况下也无需做修改)
(2).maximumPoolSize:线程池中所允许创建最大线程数量
(3).keepAliveTime:当线程池中的线程数量大于核心线程数，
如果这些多出的线程在经过了keepAliveTime时间后，
依然处于空闲状态，那么这些多出的空闲线程将会被结束其生命周期。
(4).unit:keepAliveTime的时间单位
(5).workQueue：线程池的缓存队列//用于存放任务的阻塞队列，当线程池中的核心线程都处在执行任务时，
提交的任务将被存储在workQueue进行缓冲。
该队列只能存放通过execute方法提交的Runnable任务。
(6).threadFactory:线程池中用于创建线程的工厂
在这里使用线程工厂的目的也是为了解耦,将创建的实现细节通过工厂进行封装，
而不是直接将创建的方式固化在ThreadPoolExecutor本身的代码中。
Thread newThread(Runnable r)
(7)RejectedExecutionHandler:线程池对拒绝任务的处理策略.
当线程池中的线程数量达到最大并且阻塞队列也已经满了无法再添加任务时，线程池所采取的处理策略。
核心方法：addWorker
addWorker(Runnable firstTask, boolean core)
ThreadPool02.jpg
总结线程池任务提交的过程：
如果线程池中实际的线程数量小于corePoolSize核心线程数,那么就启动一个新的线程进行任务的处理。
如果线程池中实际的线程数量大于等于corePoolSize核心核心线程数，则将任务放置到任务队列中进行处理。
如果由于任务队列已经满了，无法再存放新的任务，则判断线程池中实际的线程数量是否大于maximumPoolSize线程池最大容量：
如果小于，则创建新的线程执行.
否则将拒绝执行任务RejectedExecutionHandler.
ThreadPoolExecutor的其他知识点
关闭线程池
两个方法:shutdownNow()和shutdown().
ThreadPoolExecutor默认有四个拒绝策略
1、ThreadPoolExecutor.AbortPolicy() 直接抛出异常RejectedExecutionException
2、ThreadPoolExecutor.CallerRunsPolicy() 直接调用run方法并且阻塞执行
3、ThreadPoolExecutor.DiscardPolicy() 直接丢弃后来的任务
4、ThreadPoolExecutor.DiscardOldestPolicy() 丢弃在队列中队首的任务
官方定义的四种线程池
1、FixedThreadPool,数量固定的线程池，且任务队列也没有大小限制；
只有核心线程，且这里的核心线程也没有超时限制,因为它不会被回收，所以它能更快的响应
2、CachedThreadPool
线程数量不固定的线程池；可以进行自动线程回收,只有非核心线程，且最大线程数为Integer.MAX_VALUE
适合做大量的耗时较少的任务
3、SingleThreadExecutor
只有一个核心线程，所有任务都在同一线程中按序执行，这样也就不需要处理线程同步的问题.
4、ScheduledThreadPool
它的核心线程数量是固定的，而非核心线程是没有限制的，且非核心线程空闲时会被回收；适合执行定时任务和具有固定周期的任务
shutdown做了几件事：
1. 检查是否能操作目标线程
2. 将线程池状态转为SHUTDOWN
3. 中断所有空闲线程
但是只是清除一些空闲Worker，并且拒绝新Task加入，对于workQueue中的线程还是继续处理的。
STOP
拒绝所有新Task的加入，同时中断所有线程，WorkerQueue中没有执行的线程全部抛弃。
所以此时Pool是空的，WorkerQueue也是空的
Worker和Task的区别
Worker是当前线程池中的线程，而task虽然是runnable，但是并没有真正执行，只是被Worker调用了run方法，后面会看到这部分的实现。
maximumPoolSize和corePoolSize的区别：
maximumPoolSize为线程池最大容量，也就是说线程池最多能起多少Worker。
corePoolSize是核心线程池的大小，当corePoolSize满了时，
同时workQueue full（ArrayBolckQueue是可能满的） 那么此时允许新建Worker去处理workQueue中的Task，但是不能超过maximumPoolSize。
超过corePoolSize之外的线程会在空闲超时后终止。
最后附上自定义的线程池封装工具ThreadManager
使用方式:
ThreadManager.getNormalPool().execute(Runnable对象);//普通线程池
ThreadManager.getDownloadPool().execute(Runnable对象);//下载专用线程池
ThreadManager.getXxxxxPool().remove(Runnable对象);//移除任务(停止线程池执行)
/**线程管理类，管理线程池，一个应用中有多个线程池，每个线程池做自己相关的业务*/
public class ThreadManager {
private static ThreadPoolProxy mNormalPool = new ThreadPoolProxy(1, 3, 5 * 1000);
private static ThreadPoolProxy mDownloadPool = new ThreadPoolProxy(3, 3, 5 * 1000);
public static ThreadPoolProxy getNormalPool() {
return mNormalPool;
}
public static ThreadPoolProxy getDownloadPool() {
return mDownloadPool;
}
public static class ThreadPoolProxy {
private final int mCorePoolSize;
private final int mMaximumPoolSize;
private final long mKeepAliveTime;
private ThreadPoolExecutor mPool;
public ThreadPoolProxy(int corePoolSize, int maximumPoolSize, long keepAliveTime) {
this.mCorePoolSize = corePoolSize;
this.mMaximumPoolSize = maximumPoolSize;
this.mKeepAliveTime = keepAliveTime;
}
private void initPool() {
if (mPool == null || mPool.isShutdown()) {
// int corePoolSize = 1;//核心线程池大小
// int maximumPoolSize = 3;//最大线程池大小
// long keepAliveTime = 5 * 1000;//保持存活的时间
TimeUnit unit = TimeUnit.MILLISECONDS;//单位
BlockingQueue<Runnable> workQueue = null;//阻塞队列
workQueue = new ArrayBlockingQueue<Runnable>(4);//FIFO,大小有限制
// workQueue = new LinkedBlockingQueue();//
// workQueue = new PriorityBlockingQueue();
ThreadFactory threadFactory = Executors.defaultThreadFactory();//线程工厂
RejectedExecutionHandler handler = null;//异常捕获器
// handler = new ThreadPoolExecutor.DiscardOldestPolicy();//去掉队列中首个任务，将新加入的放到队列中去
// handler = new ThreadPoolExecutor.AbortPolicy();//触发异常
handler = new ThreadPoolExecutor.DiscardPolicy();//不做任何处理
// handler = new ThreadPoolExecutor.CallerRunsPolicy();//直接执行，不归线程池控制,在调用线程中执行
// new Thread(task).start();
mPool = new ThreadPoolExecutor(mCorePoolSize,
mMaximumPoolSize,
mKeepAliveTime,
unit,
workQueue,
threadFactory,
handler);
}
}
/**
* 执行任务
*
* @param task
*/
public void execute(Runnable task) {
initPool();
//执行任务
mPool.execute(task);
}
public Future<?> submit(Runnable task) {
initPool();
return mPool.submit(task);
}
public void remove(Runnable task) {
if (mPool != null && !mPool.isShutdown()) {
mPool.getQueue()
.remove(task);
}
}
}
}