多线程可以说是开发应用程序的标配了，在Java中通常情况都是通过new Thread()来创建一个工作线程，如果需要并发执行任务时，以这种方式创建线程，由于线程的频繁创建和销毁，会消耗大量的系统资源，程序出现卡顿，甚至出现OOM。因此，Java中利用了线程池，它通过对已存在线程的重用，降低了线程创建和销毁所造成的资源消耗，可以自己控制并发数，不必等待新线程的创建时间便执行任务，提高了系统的响应速度。
Java通过Executors这个类，提供了四种线程池：
- newFixedThreadPool()
- newSingleThreadExecutor()
- newCachedThreadPool()
- newScheduledThreadPool()
下面分别会为这四种不同方式创建的线程池进行分析，在此之前，先看一段ThreadPoolExecutor的构造方法源码：
ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
ThreadPoolExecutor是Java线程池中的核心类，上面四种创建线程池的方式也是通过ThreadPoolExecutor类完成的，并且以静态工厂方法模式封装在了Executors这个类中。这个构造函数是包含参数最多的，都是ThreadPoolExecutor类的关键属性。看下面分析：
- corePoolSize：核心线程数，必须大于或等于0
- maximumPoolSize：线程池的最大线程数，必须大于1
- keepAliveTime：线程在空闲时候的存活时间，必须大于或等于0
- TimeUnit：存活的时间单位
- workQueue：线程池中的任务队列，不能为空
- threadFactory：线程工厂，不能为空
- handler：线程饱和策略，不能为空
注意：在创建线程池时，后面的条件限制必须满足，否则异常。对于参数少的构造方法，threadFactory和handler会使用默认。
对于这几个属性简单了解后，接着分析之前提到的四种线程池
1、newFixedThreadPool()
private void fixPool(){
ExecutorService executorService = Executors.newFixedThreadPool(3);
for (int i = 0; i < 5; i++) {
int finalI = i;
executorService.execute(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+" --- "+ finalI);
}
});
}
}
//...1 Executors类newFixedThreadPool()源码
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
输出：
pool-1-thread-2 --- 1
pool-1-thread-1 --- 0
pool-1-thread-3 --- 2
pool-1-thread-1 --- 4
pool-1-thread-2 --- 3
在上面代码注释1处可以知道，用newFixedThreadPool()创建的线程池，其核心线程数和最大线程数是相同的，且无超时限制(线程空闲是不会被终止(回收))。采用了LinkedBlockingQueue阻塞队列。根据输出结果分析：当添加前三个任务时，若无空闲线程的情况下会创建一个新的线程去执行任务。当达到创建线程池时设定的核心线程数后，后续的任务会被放进阻塞队列LinkedBlockingQueue中，等待前面的线程执行完成后才进行提交。
2、newSingleThreadExecutor()
private void singlePool(){
ExecutorService executorService = Executors.newSingleThreadExecutor();
for (int i = 0; i < 3; i++) {
final int finalI = i;
executorService.execute(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+" "+ finalI);
}
});
}
}
// Executors类newSingleThreadExecutor()源码
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}
输出：
pool-1-thread-1 0
pool-1-thread-1 1
pool-1-thread-1 2
pool-1-thread-1 3
pool-1-thread-1 4
newSingleThreadExecutor()创建一个单线程的线程池，根据输出结果分析：串行的执行任务，若线程处于工作状态，任务会被放进阻塞队列LinkedBlockingQueue中，等待前面任务执行完成才会提交。
3、newCachedThreadPool()
private void cachePool(){
ExecutorService executorService = Executors.newCachedThreadPool();
for (int i = 0; i < 5; i++) {
final int finalI = i;
executorService.execute(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+" --- "+ finalI);
}
});
}
}
// Executors类newCachedThreadPool()源码
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
输出：
pool-1-thread-1 --- 0
pool-1-thread-3 --- 2
pool-1-thread-2 --- 1
pool-1-thread-5 --- 4
pool-1-thread-4 --- 3
newCachedThreadPool()创建的线程池，核心线程数是0；最大线程数是最大常数。设定了线程空闲时的存活时间为60s；SynchronousQueue队列不会存放任务，任务到来时就会被提交，执行。从输出结果可以发现：我们提交了5个任务，直接创建了5个线程进行执行。但是，在提交新任务时，如果有存在空闲的线程，则会重用这个空闲线程。我们改下上面代码，再看下输出结果。
private void cachePool(){
ExecutorService executorService = Executors.newCachedThreadPool();
for (int i = 0; i < 5; i++) {
final int finalI = i;
executorService.execute(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+" --- "+ finalI);
}
});
//每隔一秒提交一次
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
输出：
pool-1-thread-1 --- 0
pool-1-thread-2 --- 1
pool-1-thread-1 --- 2
pool-1-thread-2 --- 3
pool-1-thread-1 --- 4
4、newScheduledThreadPool()
private void scheduledPool(){
ScheduledExecutorService executorService = Executors.newScheduledThreadPool(3);
executorService.schedule(new Runnable() {
@Override
public void run() {
System.out.println("延时执行");
}
},2, TimeUnit.SECONDS);
}
// Executors类newScheduledThreadPool()源码
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
return new ScheduledThreadPoolExecutor(corePoolSize);
}
//ScheduledExecutorService的构造方法
public ScheduledThreadPoolExecutor(int corePoolSize) {
super(corePoolSize, Integer.MAX_VALUE,
DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
new DelayedWorkQueue());
}
newScheduledThreadPool()创建的线程池，核心线程数自定义，最大线程数为最大常数。空闲时的存活时间默认DEFAULT_KEEPALIVE_MILLIS = 10ms，DelayedWorkQueue延时队列。上面的代码创建的是延时执行一次任务。还可利用scheduleAtFixedRate创建一个定时循环执行任务。
ScheduledExecutorService executorService = Executors.newScheduledThreadPool(3);
executorService.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out.println("定时循环执行");
}
},10,3000, TimeUnit.MILLISECONDS);
上面代码，创建了一个定时循环执行任务的线程池。初始执行延迟10ms，后续每一次任务相隔3000ms。
scheduleAtFixedRate和scheduleWithFixedDelay类似，其中的区别：scheduleAtFixedRate的相隔时间是上个线程执行开始到下个线程执行开始的时间。
scheduleWithFixedDelay的相隔时间是上个线程执行结束到下个线程执行开始的时间。
除了上面四种方式创建线程池，我们也可以通过ThreadPoolExecutor类自定义创建线程池，下面看一段AsyncTask中的源码(自定义线程池)
private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));
private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
private static final int KEEP_ALIVE_SECONDS = 30;
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
sPoolWorkQueue, sThreadFactory);
//允许核心线程超时终止
threadPoolExecutor.allowCoreThreadTimeOut(true);
//sPoolWorkQueue
private static final BlockingQueue<Runnable> sPoolWorkQueue =
new LinkedBlockingQueue<Runnable>(128);
//sThreadFactory
private static final ThreadFactory sThreadFactory = new ThreadFactory() {
private final AtomicInteger mCount = new AtomicInteger(1);
public Thread newThread(Runnable r) {
return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
}
};
线程池的关闭：
利用shutdown()或shutdownNow()关闭线程池
- shutdown()：把线程池的状态设置为SHUTDOWN状态，中断所有没有正在执行任务的线程池。
- shutdownNow()：把线程池的状态设置为STOP状态，中断所有的线程，包括正在执行任务的线程。
前面对线程池几个属性和创建方式进行了简单的阐述，下面再对几个属性进行详解：
- corePoolSize（核心线程数）：若线程池中的线程数小于corePoolSize，这时提交任务会创建新的线程执行。若大于或等于corePoolSize，提交任务时会根据是否存在空闲线程，决定是否创建新的线程来执行任务。也可以通过prestartCoreThread()或prestartAllCoreThreads()提前启动核心线程。
- maximumPoolSize（最大线程数）：线程池中允许的最大线程数量，如果线程池的队列已满，且线程数小于maximumPoolSize，会创建新的线程执行任务，否则会被拒绝（RejectedExecutionException）
- keepAliveTime（线程空闲存活时间）：这个超时限制是对超过corePoolSize的线程的控制，如果核心线程也要实现这个机制，可以利用allowCoreThreadTimeOut(true)进行设置
- TimeUnit（单位时间）：NANOSECONDS（纳秒），MICROSECONDS（微妙），MILLISECONDS（毫秒），SECONDS（秒），MINUTES（分），HOURS（小时），DAYS（天）；
- BlockingQueue（任务队列）：存放等待执行任务的阻塞队列。在线程数小于corePoolSize时，会创建新线程执行任务，不会进行排队。大于corePoolSize时，任务会添加到队列。若队列已满，且线程数不超过maximumPoolSize，则会创建新线程执行任务。否则会被拒绝。
- ThreadFactory（线程工厂）：用于创建新的线程，设置线程优先级。
- RejectedExecutionHandler（线程饱和策略）：
ThreadPoolExecutor.AbortPolicy：处理程序遭到拒绝，则直接抛出运行时异常 RejectedExecutionException。(默认策略)
ThreadPoolExecutor.CallerRunsPolicy：由调用线程执行该任务。策略实现了一种调节机制，不会抛弃任务，也不会抛出异常。
ThreadPoolExecutor.DiscardPolicy：无法执行的任务将被删除。
ThreadPoolExecutor.DiscardOldestPolicy：会先丢弃保存时间最长的任务(队列列头开始)，然后尝试添加新任务（失败后会重复前面的步骤）
常见的工作队列(BlockingQueue)：
- ArrayBlockingQueue ：基于数组的有界阻塞队列，当队列已满后添加会遭到拒绝。
- LinkedBlockingQueue：基于链表的阻塞队列（默认 Integer.MAX_VALUE），但可以通过构造函数去改变队列长度。
- SynchronousQueue：一种直接提交策略，特性：添加一次任务，必须等待线程取走这次任务后才能添加其它任务。
- PriorityBlockingQueue：优先级阻塞队列，插入元素时会按照定义的排序规则来对元素数组进行排序，入队的元素必须实现Comparable接口，执行时优先级高的会先被取出。
