前面我们对并发有了一定的认识，并且知道如何创建线程，创建线程主要依靠的是Thread 的类来完成的，那么有什么缺陷呢？如何解决？
一、对比new Thread
new Thread的弊端
a. 每次new Thread新建对象性能差。
b. 线程缺乏统一管理，可能无限制新建线程，相互之间竞争，及可能占用过多系统资源导致死机或oom。
c. 缺乏更多功能，如定时执行、定期执行、线程中断。
相比new Thread，Java提供的四种线程池的好处在于：
a. 重用存在的线程，减少对象创建、消亡的开销，性能佳。
b. 可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞。
c. 提供定时执行、定期执行、单线程、并发数控制等功能。
二、创建线程池方法
一般通过调用Executors的工厂方法创建线程池，常用的有以下5种类:
//创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待
Executors.newFixedThreadPool
//创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行
Executors.newSingleThreadExecutor
//创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程
Executors.newCachedThreadPool
//创建一个定长线程池，支持定时及周期性任务执行
Executors.newScheduledThreadPool
//创建一个单线程化的线程池，支持定时及周期性任务执行
Executors.newSingleThreadScheduledExecutor
上面每种出基本的参数使用外，还可以根据个人需要加入ThreadFactory（java的线程生成工厂，可以自己重写做些命名日志之类）参数。如:newFixedThreadPool有重载两种方法：newFixedThreadPool(int) 和 newFixedThreadPool(int,ThreadFactory)
调用上面的方法其实都是创建ThreadPoolExecutor对象，只是传入的参数不同而已。
ThreadPoolExecutor的类方法：ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, ...)，可定义线程池固定的线程数及最大线程数。
三、执行
一般通过调用execute(Runnable) 或者 submit(Callable)执行线程
四、关闭
详细可参考:
深入理解JAVA–线程池（二）：shutdown、shutdownNow、awaitTermination
JAVA线程池shutdown和shutdownNow的区别
threadPoolExecutor 中的 shutdown() 、 shutdownNow() 、 awaitTermination() 的用法和区别
threadPool.shutdown(): 不接受新任务，已提交的任务继续执行
Initiates an orderly shutdown in which previously submitted
tasks are executed, but no new tasks will be accepted.
Invocation has no additional effect if already shut down.
List<Runnable> shutdownNow(): 阻止新来的任务提交，同时会尝试中断当前正在运行的线程，返回等待执行的任务列表
Attempts to stop all actively executing tasks, halts the
processing of waiting tasks, and returns a list of the tasks
that were awaiting execution.
awaitTermination(long timeout, TimeUnit unit):等所有已提交的任务（包括正在跑的和队列中等待的）执行完或者超时或者被中断。
线程池状态： isShutdown():if this executor has been shut down. isTerminated():if all tasks have completed following shut down.isTerminated is never true unless either shutdown or shutdownNow was called first
如何选择：
* 优雅的关闭，用shutdown()
* 想立马关闭，并得到未执行任务列表，用shutdownNow()
* 优雅的关闭，并允许关闭声明后新任务能提交，用awaitTermination()
五、常用线程池
newFixedThreadPool
要应用场景：固定线程数的线程池比较常见，如处理网络请求等。常用！！！
使用示例
/ 调用execute
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 10; i++) {
final int index = i;
fixedThreadPool.execute(new Runnable() {
public void run() {
System.out.println(index);
});
} // 调用submit
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
List<Future> futureList = new ArrayList<Future>();
for (int i = 0; i < 10; i++) {
final int index = i;
futureList.add(fixedThreadPool.submit(new Callable<Integer>() {
public Integer call() throws Exception {
return index;
}
}));
}
for(Future future : futureList) {
try {
future.get();
} catch (Exception e) {
future.cancel(true);
}
}
newCachedThreadPool
主要应用场景：需要很极致的速度，因为newCachedThreadPool不会等待空闲线程。但有一定风险，如果一个任务很慢或者阻塞，并且请求很多，就容易造成线程泛滥，会导致整个系统的假死（无法接收处理新的请求），所以实际上个人不建议使用这个方法。
使用示例：execute、submit类似于newFixedThreadPool
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
for (int i = 0; i < 10; i++) {
final int index = i;
cachedThreadPool.execute(new Runnable() {
public void run() {
System.out.println(index);
}
});
}
newSingleThreadExecutor
使用示例：execute、submit类似于newFixedThreadPool
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
for (int i = 0; i < 10; i++) {
final int index = i;
singleThreadExecutor.execute(new Runnable() {
public void run() {
System.out.println(index);
});
}
newScheduledThreadPool
执行newScheduledThreadPool返回类ScheduledExecutorService(其实新建类ScheduledThreadPoolExecutor)。
通过类ScheduledThreadPoolExecutor的定义:class ScheduledThreadPoolExecutor extends ThreadPoolExecutor implements ScheduledExecutorService及源码可知:
1、ScheduledThreadPoolExecutor是ScheduledExecutorService的实现类。
2、ScheduledThreadPoolExecutor继承了类ThreadPoolExecutor
通常我们通过Executors工厂方法(Executors.newScheduledThreadPool)获取类ScheduledExecutorService或直接通过new ScheduledThreadPoolExecutor类创建定时任务。
ScheduledThreadPoolExecutor有以下重载方法：
方法返回接口：ScheduledFuture。接口定义为:public interface ScheduledFuture<V> extends Delayed, Future<V>。对应着有以下几种常用的方法： cancel:取消任务 getDelay:获取任务还有多久执行
public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit)
延迟delay执行，只执行一次
使用示例
// 延迟3s执行
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
scheduledThreadPool.schedule(new Runnable() {
public void run() {
System.out.println("delay 3 seconds");
}
}, 3, TimeUnit.SECONDS); //延迟1秒后每3秒执行一次
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
ScheduledFuture<?> scheduledFuture = scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
public void run() {
System.out.println("delay 1 seconds, and excute every 3 seconds");
}
}, 1, 3, TimeUnit.SECONDS); //获取下一次任务还有多久执行
scheduledFuture.getDelay(TimeUnit.SECONDS)
public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)
延迟initialDelay开始执行执行，之后周期period执行，类比Timer的scheduleAtFixedRate方法，固定频率执行。当某个任务执行的时间超过period时间，则可能导致下一个定时任务延迟，但是不会出现并发执行的情况。当任何一个任务执行跑出异常，后面的任务将不会执行。所以你如果想保住任务都一直被周期执行，那么catch一切可能的异常。通过取消任务(调用cancel方法)或者终止executor(调用shutdown方法)可使任务停止。
public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)
延迟initialDelay开始执行执行，之后周期period执行，类比Timer的schedule方法，固定延迟执行。当上一个任务执行后，等待delay时间才执行下一个，因此也不会并发执行的情况。当任何一个任务执行跑出异常，后面的任务将不会执行。所以你如果想保住任务都一直被周期执行，那么catch一切可能的异常。通过取消任务(调用cancel方法)或者终止executor(调用shutdown方法)可使任务停止。
六、ScheduledThreadPoolExecutor与Timer的区别
直接参考:Timer与ScheduledThreadPoolExecutor
参考: