系统启动一个新线程需要很高的成本，因为它涉及与操作系统交互。在这种情况下，使用线程池可以很好地提高性能，尤其是当程序中需要创建大量生存期很短暂的线程时。
线程池在系统启动时即创建大量空闲的线程，程序将一个Runnable对象或Callable对象传给线程池，线程池就会启动一个线程来run()或call()方法，当run()或call()方法执行结束后，该线程并不会死亡，而是再次返回线程池中成为空闲状态，等待执行下一个Runnable对象的run()或call()方法。除此之外，使用线程池可以有效地控制系统中并发线程的数量。
使用Executors类来创建线程池：
| 方法名 | |
|---|---|
| newCachedThreadPool() | 创建一个具有缓存功能的线程池，系统根据需要创建线程，这些线程将会被缓存在线程池中 |
| newFixedThreadPool(int nThreads) | 创建一个可重用的、具有固定线程数的线程池 |
| newSingleThreadExecutor() | 创建一个只有单线程的线程池，它相当与调用newFixedThreadPool()方法时传入参数为1 |
| newScheduledThreadPool(int corePoolSize) | 创建具有指定线程数的线程池，它可以在指定延迟后执行线程任务。corePoolSize指池中所保存的线程数，即使线程是空闲的也被保存在线程池内。 |
| newSingleThreadScheduledExecutor() | 创建只有一个线程的线程池，它可以在指定延迟后执行线程任务 |
| ExecutorService newWorkStealingPool(int parallelism) | 创建持有足够的线程的线程池来支持给定的并行级别，该方法还会使用多个队列来减少竞争 |
| ExecutorService newWorkStealingPool() | 该方法是前一个方法的 简化版本，如果当前机器有4个CPU，则目标并行级别被设置为4，也就是相当于为前一个方法传入4作为参数。 |
使用线程池来执行线程任务的步骤：
1.调用Executors类的静态工厂方法创建一个ExecutorService对象，该对象代表一个线程池。
2.创建Runnable实现类或Callable实现类的实例，作为线程执行任务。
3.调用ExecutorService对象的submit()方法来提交Runnable实例或Callable实例。
4.当不想提交任何任务时，调用ExecutorService对象的shutdown()方法来关闭线程池。
使用线程池来执行指定Runnable对象所代表的的任务：
public class ThreadPoolTest {
public static void main(String[] args)throws Exception{
//创建一个具有固定线程数（6）的线程池
ExecutorService pool = Executors.newFixedThreadPool(6);
//使用Lambda表达式创建Runnable对象
Runnable target = () -> {
for(int i = 0; i < 100; i++){
System.out.println(Thread.currentThread().getName() + "的i值为：" + i);
}
};
//向线程池中提交两个线程
pool.submit(target);
pool.submit(target);
//关闭线程池
pool.shutdown();
}
}ForkJoinPool类
ForkJoinPool类的作用是将一个任务拆分为多个“小任务”并行计算，再把多个“小任务”的结果合并成总的计算结果。ForkJoinPool类是ExecutorService的实现类，因此是一种特殊的线程池。
| 方法 | |
|---|---|
| ForkJoinPool(int parallelism) | 创建一个包含parallelism个并行线程的ForkJoinPool |
| ForkJoinPool() | 以runtime.availableprocessors（处理器数量）返回值为parallelism参数来创建ForkJoinPool。 |
| ForkJoinPool commonPool() | 该方法返回一个通用池，通用池的运行状态不回受shutdown()或shutdownNow()方法的影响。 |
| int getCommonPoolParallelism() | 返回通用池的并行级别 |
创建了ForkJoinPool实例之后，就可调用ForkJoinPool的submit（ForkJoinTask task）或invoke（ForkJoinTask task）方法来执行指定任务。其中ForkJoinTask代表一个可以并行、合并的任务。ForkJoinTask是一个抽象类，它还有两个抽象子类：RecursiveAction（没有返回值）和RecursiveTask（有返回值）。
没有返回值的“大任务”拆分：
//继承RecursiveAction来实现“可分解”的任务
class PrintTask extends RecursiveAction{
//每个“小任务”最多打印50个数
private static final int THRESHOLD = 50;
private int start;
private int end;
//打印从start到end的任务
public PrintTask(int start, int end){
this.start = start;
this.end = end;
}
@Override
protected void compute() {
// 当end与start之间的差小于THRESHOLD时，开始打印
if(end - start < THRESHOLD){
for(int i = 0; i < end; i++){
System.out.println(Thread.currentThread().getName() + "的i值：" + i);
}
}else{
//当end与start之间的差大于THRESHOLD时，开始打印
//将大任务分解成两个“小任务”
int middle = (start + end) / 2;
PrintTask left = new PrintTask(start, middle);
PrintTask right = new PrintTask(middle, end);
//并执行两个“小任务”
left.fork();
right.fork();
}
}
}
public class ForkJoinPoolTest {
public static void main(String[] args)throws Exception{
ForkJoinPool pool = new ForkJoinPool();
//提交可分解的PrintTask任务
pool.submit(new PrintTask(0, 300));
pool.awaitTermination(2, TimeUnit.SECONDS);
//关闭线程池
pool.shutdown();
}
}有返回值的“大任务”：
//继承RecursiveTask来实现“可分解”的任务
class CalTask extends RecursiveTask<Integer>{
//每个“小任务”最多只累加20个数
private static final int THRESHOLD = 20;
private int arr[];
private int start;
private int end;
//累加从start到end数组
public CalTask(int[] arr, int start, int end){
this.arr = arr;
this.start = start;
this.end = end;
}
@Override
protected Integer compute() {
int sum = 0;
// 当end与start之间的差小于THRESHOLD时，开始进行实际累加
if(end - start < THRESHOLD){
for(int i = start; i < end; i++){
sum += arr[i];
}
return sum;
}else{
//当end与start之间的差大于THRESHOLD，既要累加的数超过20个时，将大任务分解成两个小任务
int middle = (start + end) / 2;
CalTask left = new CalTask(arr, start, middle);
CalTask right = new CalTask(arr, middle, end);
//并执行两个小任务
left.fork();
right.fork();
//把两个小任务累加的结果合并起来
return left.join() + right.join();
}
}
}
public class Sum {
public static void main(String[] args)throws Exception{
int[] arr = new int[100];
Random rand = new Random();
int total = 0;
//初始化100个数字元素
for(int i = 0, len = arr.length; i < len; i++){
int tmp = rand.nextInt(20);
//对数组元素赋值，并将数组元素的值添加到sum总和中
System.out.println(tmp);
total += (arr[i] = tmp);
}
System.out.println("初始化统计出的和：" + total);
//创建一个通用池
ForkJoinPool pool = ForkJoinPool.commonPool();
//提交可分解的CaltTask任务
Future<Integer> future = pool.submit(new CalTask(arr, 0, arr.length));
System.out.println("使用CalTask计算出的和：" + future.get());
//关闭线程
pool.shutdown();
}
}