一、概述
New Thread的弊端如下：
a、每次New Thread新建对象性能差。
b、线程缺乏统一的管理，可能无限制的新建线程，相互之间竞争，极可能占用过多的系统资源导致死机 或者 OOM。
c、缺乏更多功能，如定时执行、定期执行、线程中断。
Java提供的四种线程池的好处在于：
a、重用存在的线程，减少对象创建、消亡的开销，性能佳。
b、可有效控制最大并发线程数、提供系统资源的使用率，同时避免过多资源竞争，避免堵塞。
c、提供定时执行、定期执行、单线程、并发数控制等功能。
二、Executors 创建线程池
Java通过Executors提供四种线程池，分别为：
newCachedThreadPool 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待，表示同一时刻只能有这么大的并发数
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
三、ThreadPoolExecutor 创建线程池
线程池不建议使用Executors去创建，而是通过ThreadPoolExecutor的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。 说明：Executors各个方法的弊端：
1、 newFixedThreadPool和newSingleThreadExecutor:
主要问题是堆积的请求处理队列可能会耗费非常大的内存，甚至OOM。
2、newCachedThreadPool和newScheduledThreadPool:
主要问题是线程数最大数是Integer.MAX_VALUE，可能会创建数量非常多的线程，甚至OOM。
这里介绍三种创建线程池的方式：
Example 1：
//org.apache.commons.lang3.concurrent.BasicThreadFactory
ScheduledExecutorService executorService = new ScheduledThreadPoolExecutor(1,new BasicThreadFactory.Builder().namingPattern("example-schedule-pool-%d").daemon(true).build());
Example 2：
ThreadFactory namedThreadFactory = new ThreadFactoryBuilder().setNameFormat("demo-pool-%d").build();
//Common Thread Pool
ExecutorService pool = new ThreadPoolExecutor(5, 200,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>(1024), namedThreadFactory, new ThreadPoolExecutor.AbortPolicy());
pool.execute(()-> System.out.println(Thread.currentThread().getName()));
pool.shutdown();//gracefully shutdown
Example 3：
<bean id="userThreadPool" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
<property name="corePoolSize" value="10" />
<property name="maxPoolSize" value="100" />
<property name="queueCapacity" value="2000" />
<property name="threadFactory" value= threadFactory />
<property name="rejectedExecutionHandler">
<ref local="rejectedExecutionHandler" />
</property>
</bean>
//in code
userThreadPool.execute(thread);
另外贴一个我在工作中经常使用的线程池的创建：
public class ThreadPoolHelper {
private static final Logger logger = Logger.getLogger(ThreadPoolHelper.class);
private static final int POOL_SIZE = 40;//线程池大小
//订单任务线程池
private static ThreadPoolExecutor comitTaskPool =(ThreadPoolExecutor) new ScheduledThreadPoolExecutor(POOL_SIZE,
new BasicThreadFactory.Builder().namingPattern("example-schedule-pool-%d").daemon(true).build());
/**
* 执行订单任务
*
* @param comitTask
*/
public static void executeTask(Runnable comitTask) {
comitTaskPool.execute(comitTask);
logger.debug("【线程池任务】线程池中线程数：" + comitTaskPool.getPoolSize());
logger.debug("【线程池任务】队列中等待执行的任务数：" + comitTaskPool.getQueue().size());
logger.debug("【线程池任务】已执行完任务数：" + comitTaskPool.getCompletedTaskCount());
}
/**
* 关闭线程池
*/
public static void shutdown() {
logger.debug("shutdown comitTaskPool...");
comitTaskPool.shutdown();
try {
if (!comitTaskPool.isTerminated()) {
logger.debug("直接关闭失败[" + comitTaskPool.toString() + "]");
comitTaskPool.awaitTermination(3, TimeUnit.SECONDS);
if (comitTaskPool.isTerminated()) {
logger.debug("成功关闭[" + comitTaskPool.toString() + "]");
} else {
logger.debug("[" + comitTaskPool.toString() + "]关闭失败，执行shutdownNow...");
if (comitTaskPool.shutdownNow().size() > 0) {
logger.debug("[" + comitTaskPool.toString() + "]没有关闭成功");
} else {
logger.debug("shutdownNow执行完毕，成功关闭[" + comitTaskPool.toString() + "]");
}
}
} else {
logger.debug("成功关闭[" + comitTaskPool.toString() + "]");
}
} catch (InterruptedException e) {
logger.warn("接收到中断请" + comitTaskPool.toString() + "停止操作");
}
}
}