一、线程池介绍
在一个应用程序中，如果需要多次使用线程就意味着需要多次创建并销毁线程。而创建并销毁线程的过程势必会消耗内存。而在Java中，内存资源是及其宝贵的，所以很有必要对多线程进行管理。Java中开辟出了一种管理线程的概念，这个概念叫做线程池。
Java中已经提供了创建线程池的一个类：Executor而我们创建线程池时，一般使用它的子类：ThreadPoolExecutor
ThreadPoolExecutor类是线程池中最核心的一个类，因此如果要透彻地了解Java中的线程池，必须先了解这个类。来看一下ThreadPoolExecutor类的具体实现源码。
在ThreadPoolExecutor类中提供了四个构造方法：
public class ThreadPoolExecutor extends AbstractExecutorService {
.....
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
BlockingQueue<Runnable> workQueue);
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory);
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
BlockingQueue<Runnable> workQueue,RejectedExecutionHandler handler);
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler);
...
}
从上面的代码可以得知，ThreadPoolExecutor继承了AbstractExecutorService类，并提供了四个构造器，事实上，通过观察每个构造器的源码具体实现，发现前面三个构造器都是调用的第四个构造器进行的初始化工作。
下面解释下一下构造器中各个参数的含义：
corePoolSize：核心池的大小，这个参数跟后面讲述的线程池的实现原理有非常大的关系。在创建了线程池后，默认情况下，线程池中并没有任何线程，而是等待有任务到来才创建线程去执行任务，除非调用了prestartAllCoreThreads()或者prestartCoreThread()方法，从这2个方法的名字就可以看出，是预创建线程的意思，即在没有任务到来之前就创建corePoolSize个线程或者一个线程。默认情况下，在创建了线程池后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中；
maximumPoolSize：线程池最大线程数，这个参数也是一个非常重要的参数，它表示在线程池中最多能创建多少个线程；
keepAliveTime：表示线程没有任务执行时最多保持多久时间会终止。默认情况下，只有当线程池中的线程数大于corePoolSize时，keepAliveTime才会起作用，直到线程池中的线程数不大于corePoolSize，即当线程池中的线程数大于corePoolSize时，如果一个线程空闲的时间达到keepAliveTime，则会终止，直到线程池中的线程数不超过corePoolSize。但是如果调用了allowCoreThreadTimeOut(boolean)方法，在线程池中的线程数不大于corePoolSize时，keepAliveTime参数也会起作用，直到线程池中的线程数为0；
unit：参数keepAliveTime的时间单位，有7种取值，在TimeUnit类中有7种静态属性：
TimeUnit.DAYS; //天
TimeUnit.HOURS; //小时
TimeUnit.MINUTES; //分钟
TimeUnit.SECONDS; //秒
TimeUnit.MILLISECONDS; //毫秒
TimeUnit.MICROSECONDS; //微妙
TimeUnit.NANOSECONDS; //纳秒
workQueue：一个阻塞队列，用来存储等待执行的任务，这个参数的选择也很重要，会对线程池的运行过程产生重大影响，一般来说，这里的阻塞队列有以下几种选择：
ArrayBlockingQueue;
LinkedBlockingQueue;
SynchronousQueue;
ArrayBlockingQueue和PriorityBlockingQueue使用较少，一般使用LinkedBlockingQueue和Synchronous。线程池的排队策略与BlockingQueue有关。
threadFactory：线程工厂，主要用来创建线程；
handler：表示当拒绝处理任务时的策略，有以下四种取值：
ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务
Executor是一个顶层接口，在它里面只声明了一个方法execute(Runnable)，返回值为void，参数为Runnable类型，从字面意思可以理解，就是用来执行传进去的任务的；然后ExecutorService接口继承了Executor接口，并声明了一些方法：submit、invokeAll、invokeAny以及shutDown等；
抽象类AbstractExecutorService实现了ExecutorService接口，基本实现了ExecutorService中声明的所有方法；然后ThreadPoolExecutor继承了类AbstractExecutorService。
在ThreadPoolExecutor类中有几个非常重要的方法：
execute()
submit()
shutdown()
shutdownNow()
execute()方法实际上是Executor中声明的方法，在ThreadPoolExecutor进行了具体的实现，这个方法是ThreadPoolExecutor的核心方法，通过这个方法可以向线程池提交一个任务，交由线程池去执行。
submit()方法是在ExecutorService中声明的方法，在AbstractExecutorService就已经有了具体的实现，在ThreadPoolExecutor中并没有对其进行重写，这个方法也是用来向线程池提交任务的，但是它和execute()方法不同，它能够返回任务执行的结果，去看submit()方法的实现，会发现它实际上还是调用的execute()方法，只不过它利用了Future来获取任务执行结果。
shutdown()和shutdownNow()是用来关闭线程池的。
二、线程池的简单使用
通过一个简单的图片下载功能进行理解
1. 首先创建一个测试类，实现单例模式和初始化工作
public class ThreadPoolTest {
/**
* 线程池大小
*/
private static final int CORE_POOL_SIZE = 4;
/**
* 最大线程数
*/
private static final int MAXIMUM_POOL_SIZE = 5;
/**
* 空闲线程存活时间为2秒
*/
private static final long KEEP_ALIVE_TIME = 2;
private ThreadPoolExecutor mThreadPoolExecutor;
private BlockingQueue<Runnable> mBlockingDeque;
private Context mContext;
private Handler handler;
private static ThreadPoolTest threadPoolTest;
private ThreadPoolTest() {
}
public static ThreadPoolTest getInstance(){
if(threadPoolTest == null){
synchronized (ThreadPoolTest.class){
if(threadPoolTest == null){
threadPoolTest = new ThreadPoolTest ();
}
}
}
return threadPoolTest;
}
public void initTest(){
mBlockingDeque = new LinkedBlockingDeque<> ();
mThreadPoolExecutor = new ThreadPoolExecutor (CORE_POOL_SIZE,MAXIMUM_POOL_SIZE,KEEP_ALIVE_TIME, TimeUnit.SECONDS,mBlockingDeque);
handler = new Handler ();
}
}
2. 添加一个内部任务操作类
public class ThreadPoolTask implements Runnable {
private String imageUrl;
private ImageView imageView;
private Bitmap bitmap;
public ThreadPoolTask(String url, ImageView iv) {
this.imageUrl = url;
this.imageView = iv;
}
@Override
public void run() {
boolean flag = true;
try {
while (flag) {
bitmap = downImage (imageUrl);
//图片下载完成，handler通知主线程更新界面
if(handler != null) {
handler.post (new Runnable () {
@Override
public void run() {
imageView.setImageBitmap (bitmap);
}
});
}
flag = false;
}
} catch (Exception e) {
e.printStackTrace ();
}
}
public Bitmap downImage(String imageUrl) {
InputStream inputStream;
Bitmap bitmap = null;
try {
URL url = new URL (imageUrl);
HttpURLConnection connection = (HttpURLConnection) url.openConnection ();
connection.connect ();
inputStream = connection.getInputStream ();
bitmap = BitmapFactory.decodeStream (inputStream);
inputStream.close ();
} catch (IOException e) {
e.printStackTrace ();
}
return bitmap;
}
}
3. 添加一个执行方法 ，提供给需要进行操作的Activity或Fragment使用
public void startThread(String imageUrl, ImageView iv) {
try {
TestTask task = new TestTask (imageUrl, iv);
mThreadPoolExecutor.execute (task);
} catch (Exception e) {
Log.e ("threadtest", "已超出规定的线程数量");
}
}
4. 使用线程池进行图片下载
threadPoolTest = ThreadPoolTest .getInstance ();
threadPoolTest .initTest();
iv = view.findViewById (R.id.profile_photo_iv);
String imgUrl = "图片网络地址";
threadPoolTest .startThread (imgUrl,ivProfilePhoto);
