Java里面线程池的顶级接口是Executor，但是严格意义上讲Executor并不是一个线程池，而只是一个执行线程的工具，它真正的线程池接口是ExecutorService。
使用线程池能够为了防止资源不足，因为频繁创建和销毁线程会消耗大量资源，尤其是当线程执行时间>线程创建时间+线程销毁时间，此时会堆积大量线程。Java中，创建线程池有四种方式，如下：
1）newCachedThreadPool()
创建一个可缓存线程池，线程池为无限大，如果线程池长度超过处理需要，可灵活回收空闲线程，即当执行当前任务时上一个任务已经完成，会复用执行上一个任务的线程，而不用每次新建线程；如果上一个线程没有结束则会新建线程。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class CachedThreadPool {
private static ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
public static void main(String args[]) {
for (int i = 0; i < 10; i++) {
try {
if (i == 4) {
Thread.sleep(2000);
}
} catch (Exception e) {
e.getStackTrace();
}
cachedThreadPool.execute(new Runnable() {
public void run() {
try {
Thread.sleep(1000);
} catch (Exception e) {
e.getStackTrace();
}
System.out.println(Thread.currentThread().getName() + "正在被执行");
}
});
}
}
/**
* 执行结果如下(console输出):
* pool-1-thread-1正在被执行
* pool-1-thread-4正在被执行
* pool-1-thread-3正在被执行
* pool-1-thread-2正在被执行
* pool-1-thread-4正在被执行
* pool-1-thread-1正在被执行
* pool-1-thread-3正在被执行
* pool-1-thread-2正在被执行
* pool-1-thread-5正在被执行
* pool-1-thread-6正在被执行
*/
}在i=5的时候，需停留2秒，此时线程1-4都已经释放，所以1-4线程可以复用，这就是newCachedThreadPool()线程池的优点。但是这样的写法也会带来一个缺点，就是一旦线程无限增长，会导致内存溢出。
2）newFixedThreadPool()
可重用固定个数的线程池，当当前线程数大于总线程数时会进行等待，等待线程池内的线程执行完，相对来说占用内存少，因为如果等待线程数量过多，也是相对耗废资源的。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class FixedThreadPool {
private static ExecutorService fixedThreadPool = Executors.newFixedThreadPool(4);
public static void main(String args[]) {
for (int i = 0; i < 10; i++) {
fixedThreadPool.execute(new Runnable() {
public void run() {
System.out.println(Thread.currentThread().getName() + "正在被执行");
try {
Thread.sleep(1000);
} catch (Exception e) {
e.getStackTrace();
}
}
});
}
}
}
线程池大小为4，所以如果线程执行数量超过4则会进行等待，所以newFixedThreadPool()的缺点也很明显，就是如果线程池数量设置明显过小，则会导致大量线程等待，造成资源浪费。所以一句话总结，缺点是：不支持自定义拒绝策略，大小固定，难以扩展。
3）newSingleThreadExecutor()
单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO,优先级)执行，如果该线程异常结束，会有另一个线程取代它，保证顺序执行。
所以缺点也很明显，就是单线程执行，线程多，执行速度会比较慢，所以不适合并发。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class SingleThreadPool {
private static ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();
public static void main(String args[]) {
for (int i = 0; i < 10; i++) {
final int index = i;
singleThreadPool.execute(new Runnable() {
public void run() {
try {
System.out.println(Thread.currentThread().getName() + "正在执行 index=" + index);
Thread.sleep(1000);
} catch (Exception e) {
e.getStackTrace();
}
}
});
}
}
/**
* 执行结果如下：
* pool-1-thread-1正在执行 index=0
* pool-1-thread-1正在执行 index=1
* pool-1-thread-1正在执行 index=2
* pool-1-thread-1正在执行 index=3
* pool-1-thread-1正在执行 index=4
* pool-1-thread-1正在执行 index=5
* pool-1-thread-1正在执行 index=6
* pool-1-thread-1正在执行 index=7
* pool-1-thread-1正在执行 index=8
* pool-1-thread-1正在执行 index=9
*
* 结论:所有的线程都是线程1来执行而且是有序执行，这就是单线程池！
*/
}4）newScheduledThreadPool()
可重用固定个数的线程池，当前线程数大于总数则会进行等待，并且可以设置线程延迟执行时间。
优点：一个固定大小线程池，可以定时或周期性的执行任务
缺点：任务是单线程方式执行，一旦一个任务失败其他任务也受影响
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ScheduledThreadPool {
private static ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(4);
public static void main(String args[]) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmsssss");
for (int i = 0; i < 10; i++) {
System.out.println(i + "开始执行时间" + sdf.format(new Date()));
scheduledThreadPool.schedule(new Runnable() {
public void run() {
System.out.println(Thread.currentThread().getName() + "正在执行 执行时间=" + sdf.format(new Date()));
}
}, 3, TimeUnit.SECONDS);
}
}
}
那么，使用线程池会造成什么风险呢？
1）死锁：任何的多线程都有可能发生死锁的风险(线程之间互相等待)
2）资源不足：线程池太大造成，正常来说合理创建线程池大小一般不会出现这个问题
3）线程泄漏和请求过载
>>>>>阿里巴巴开发规范<<<<<
【强制】线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。
说明：Executors 返回的线程池对象的弊端如下：
1） FixedThreadPool 和 SingleThreadPool：
允许的请求队列长度为 Integer.MAX_VALUE，可能会堆积大量的请求，从而导致 OOM。
2） CachedThreadPool 和 newScheduledThreadPool：
允许的创建线程数量为 Integer.MAX_VALUE，可能会创建大量的线程，从而导致 OOM。
所以，按照阿里巴巴的开发规范，实际编程中我们需要使用ThreadPoolExecutor创建线程池，它集以上优点于一身，比如：
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class ThreadPoolExecutorTest {
public static void main(String[] args) {
ThreadPoolExecutor executor = new ThreadPoolExecutor(1, // corePoolSize
100, // maximumPoolSize
100, // keepAliveTime
TimeUnit.SECONDS, // unit
new LinkedBlockingDeque<>(100));// workQueue
for (int i = 0; i < 5; i++) {
final int taskIndex = i;
executor.execute(() -> {
System.out.println(taskIndex);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
});
}
}
}public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler);
参数解释：
corePoolSize ： 线程池核心池的大小。
maximumPoolSize ： 线程池的最大线程数。
keepAliveTime ： 当线程数大于核心时，此为终止前多余的空闲线程等待新任务的最长时间。
unit ： keepAliveTime 的时间单位。
workQueue ： 用来储存等待执行任务的队列。
threadFactory ： 线程工厂。
handler 拒绝策略。原理：
有请求时，创建线程执行任务，当线程数量等于corePoolSize时，请求加入阻塞队列里，当队列满了时，接着创建线程，线程数等于maximumPoolSize。 当任务处理不过来的时候，线程池开始执行拒绝策略。
阻塞队列：
ArrayBlockingQueue ：一个由数组结构组成的有界阻塞队列。
LinkedBlockingQueue ：一个由链表结构组成的有界阻塞队列。
PriorityBlockingQueue ：一个支持优先级排序的无界阻塞队列。
DelayQueue： 一个使用优先级队列实现的无界阻塞队列。
SynchronousQueue： 一个不存储元素的阻塞队列。
LinkedTransferQueue： 一个由链表结构组成的无界阻塞队列。
LinkedBlockingDeque： 一个由链表结构组成的双向阻塞队列。
拒绝策略：
ThreadPoolExecutor.AbortPolicy: 丢弃任务并抛出RejectedExecutionException异常。 (默认)
ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务。（重复此过程）
ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务。
