最近学习了JAVA线程池，应用最多的线程池一般有三种 newSingleThreadExecutor、newFixedThreadPool、newCachedThreadPool
newSingleThreadExecutor 创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。
newFixedThreadPool 创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。
newCachedThreadPool 创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。
newSingleThreadExecutor 单线程池一般用于并发量不大的环境中
newCachedThreadPool 无边界线程池无疑要慎用，不然耗尽资源造成宕机后果无疑很严重
所以我推荐用newFixedThreadPool 有边界的线程池，实际大小可以根据生产环境加以调整，再加上一些拒绝任务的处理，在高并发的环境中无疑是非常好用的。
一下便是以newSingleThreadExecutor 做的例子
工作线程：
public class TestThread extends Thread {
@Override
public void run() {
TestThreadPool.testCount.addAndGet(1l);
// System.out.println(i);
}
}
线程池：
public class TestThreadPool {
// public static int testCount = 0;
public static AtomicLong testCount = new AtomicLong(0);
public static AtomicLong rejectCount = new AtomicLong(0);
private int corePoolSize = 30;
private int maximumPoolSize = 60;
private long keepAliveTime = 5l;
private TimeUnit unit = TimeUnit.SECONDS;
// private BlockingQueue<Runnable> workQueue = new
// LinkedBlockingQueue<Runnable>(
// 20);
private BlockingQueue<Runnable> workQueue = new SynchronousQueue<Runnable>();
// private ThreadPoolExecutor executor = new
// ThreadPoolExecutor(corePoolSize,
// maximumPoolSize, keepAliveTime, unit, workQueue);
private ThreadPoolExecutor executor = new ThreadPoolExecutor(corePoolSize,
maximumPoolSize, keepAliveTime, unit, workQueue,
new ThreadRejectHandler());
public static void main(String[] args) {
int circle = 1000000;
long start = Calendar.getInstance().getTimeInMillis();
TestThreadPool test = new TestThreadPool();
for (int i = 0; i < circle; i++) {
try {
test.executor.execute(new TestThread());
} catch (Exception e) {
e.printStackTrace();
}
}
for (;;) {
if ((testCount.get() + rejectCount.get()) == Long.valueOf(circle)) {
System.out.println("testCount:" + testCount);
break;
}
}
long end = Calendar.getInstance().getTimeInMillis();
System.out.println("耗时：[" + (end - start) + "] 毫秒");
test.executor.shutdownNow();
}
}
拒绝任务处理器：
public class ThreadRejectHandler implements RejectedExecutionHandler {
@Override
public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
System.out.println("任务被拒绝:"+TestThreadPool.rejectCount.addAndGet(1l));
// 在这里做拒绝任务的处理
}
}
启动类为《线程池类TestThreadPool 》，可以根据机器的配置调节circle参数的大小进行测试
我这里设置了circle为 1000000， 测试结果如下：
任务被拒绝:1
任务被拒绝:2
。。。。。。。。。。。。。此处略去N字
任务被拒绝:259
任务被拒绝:260
testCount:999740
耗时：[3266] 毫秒
=======================================================================
使用线程池的优势：
因为通常情况下，创建线程是需要一定的耗时的，设这个时间为T1，而线程处理任务的时间为T2，而销毁线程的时间为T3，当T1>>T2时，同时T3时间也是一个需要考虑的参数，我们就应当考虑一种策略或者机制来控制，避免因为T1和T3这种无用的时间过多的占用资源。
所以线程池在高并发的环境中的优势是不言而喻的