Java并发编程：Java的四种线程池的使用，以及自定义线程工厂
目录
引言
通过前面的文章，我们学习了executor框架中的核心类threadpoolexecutor ，对于线程池的核心调度机制有了一定的了解，并且成功使用threadpoolexecutor 创建了线程池。
而在java中，除了threadpoolexecutor ，executor框架中还提供了四种线程池，这四种线程池都是直接或间接配置threadpoolexecutor的参数实现的，对于threadpoolexecutor类不熟悉的读者可以参考java并发编程：java线程池核心threadpoolexecutor的使用和原理分析
四种线程池
四种线程池分别是：newcachedthreadpool、newfixedthreadpool 、newscheduledthreadpool 和newsinglethreadexecutor ，下面对这几个线程池一一讲解。
newcachedthreadpool：可缓存的线程池
源码：
public static executorservice newcachedthreadpool() {
return new threadpoolexecutor(0, integer.max_value,
60l, timeunit.seconds,
new synchronousqueue<runnable>());
}
newcachedthreadpool的方法中是返回一个threadpoolexecutor实例，从源码中可以看出该线程池的特点：
1、该线程池的核心线程数量是0，线程的数量最高可以达到integer 类型最大值；
2、创建threadpoolexecutor实例时传过去的参数是一个synchronousqueue实例，说明在创建任务时，若存在空闲线程就复用它，没有的话再新建线程。
3、线程处于闲置状态超过60s的话，就会被销毁。
用法：
public static void main(string[] args) {
//定义executorservice实例
executorservice cachedthreadpool = executors.newcachedthreadpool();
for (int i = 0; i < 10; i++) {
final int index = i;
try {
thread.sleep(index * 1000);
} catch (interruptedexception e) {
e.printstacktrace();
}
//调用execute方法
cachedthreadpool.execute(new runnable() {
@override
public void run() {
system.out.println(thread.currentthread() + ":" + index);
}
});
}
}
上面的代码因为每次循环都是隔一秒执行，这个时间足够之前的线程工作完毕，并在新循环中复用这个线程，程序的运行结果如下：
thread[pool-1-thread-1,5,main]:0 thread[pool-1-thread-1,5,main]:1 thread[pool-1-thread-1,5,main]:2 thread[pool-1-thread-1,5,main]:3 thread[pool-1-thread-1,5,main]:4 thread[pool-1-thread-1,5,main]:5 thread[pool-1-thread-1,5,main]:6 thread[pool-1-thread-1,5,main]:7 thread[pool-1-thread-1,5,main]:8 thread[pool-1-thread-1,5,main]:9
newfixedthreadpool：定长线程池
源码：
public static executorservice newfixedthreadpool(int nthreads) {
return new threadpoolexecutor(nthreads, nthreads,
0l, timeunit.milliseconds,
new linkedblockingqueue<runnable>());
}
线程池特点：
1、线程池的最大线程数等于核心线程数，并且线程池的线程不会因为闲置超时被销毁。
2、使用的列队是linkedblockingqueue，表示如果当前线程数小于核心线程数，那么即使有空闲线程也不会复用线程去执行任务，而是创建新的线程去执行任务。如果当前执行任务数量大于核心线程数，此时再提交任务就在队列中等待，直到有可用线程。
用法：
public static void main(string[] args) {
executorservice cachedthreadpool = executors.newfixedthreadpool(3);
for (int i = 0; i < 10; i++) {
final int index = i;
try {
thread.sleep(index * 1000);
} catch (interruptedexception e) {
e.printstacktrace();
}
cachedthreadpool.execute(new runnable() {
@override
public void run() {
system.out.println(thread.currentthread() + ":" + index);
}
});
}
}
定义一个线程数为3的线程池，循环10次执行，可以发现运行的线程永远只有三个，结果如下：
thread[pool-1-thread-1,5,main]:0 thread[pool-1-thread-2,5,main]:1 thread[pool-1-thread-3,5,main]:2 thread[pool-1-thread-1,5,main]:3 thread[pool-1-thread-2,5,main]:4 thread[pool-1-thread-3,5,main]:5 thread[pool-1-thread-1,5,main]:6 thread[pool-1-thread-2,5,main]:7 thread[pool-1-thread-3,5,main]:8 thread[pool-1-thread-1,5,main]:9
newsinglethreadexecutor：单线程线程池
源码：
public static executorservice newsinglethreadexecutor() {
return new finalizabledelegatedexecutorservice
(new threadpoolexecutor(1, 1,
0l, timeunit.milliseconds,
new linkedblockingqueue<runnable>()));
}
从源码就可以看出，该线程池基本就是只有一个线程数的newfixedthreadpool，它只有一个线程在工作，所有任务按照指定顺序执行。
用法：
和newfixedthreadpool类似，只是一直只有一个线程在工作，这里就不贴代码了。
newscheduledthreadpool：支持定时的定长线程池
源码：
public static scheduledexecutorservice newscheduledthreadpool(int corepoolsize) {
return new scheduledthreadpoolexecutor(corepoolsize);
}
public scheduledthreadpoolexecutor(int corepoolsize) {
super(corepoolsize, integer.max_value, 0, nanoseconds,
new delayedworkqueue());
}
public threadpoolexecutor(int corepoolsize,
int maximumpoolsize,
long keepalivetime,
timeunit unit,
blockingqueue<runnable> workqueue) {
this(corepoolsize, maximumpoolsize, keepalivetime, unit, workqueue,
executors.defaultthreadfactory(), defaulthandler);
}
newscheduledthreadpool的方法不是直接返回一个threadpoolexecutor实例，而是通过有定时功能的threadpoolexecutor，也就是scheduledthreadpoolexecutor 来返回threadpoolexecutor实例，从源码中可以看出：
1、该线程池可以设置核心线程数量，最大线程数与newcachedthreadpool一样，都是integer.max_value。
2、该线程池采用的队列是delayedworkqueue，具有延迟和定时的作用。
用法：
public static void main(string[] args) {
executorservice scheduledthreadpool = executors.newscheduledthreadpool(3);
//延迟3秒执行，只执行一次
((scheduledexecutorservice) scheduledthreadpool).schedule(new runnable() {
@override
public void run() {
system.out.println("延迟========");
}
},3,timeunit.seconds);
//延迟1秒后每隔两秒执行一次
((scheduledexecutorservice) scheduledthreadpool).scheduleatfixedrate(new runnable() {
@override
public void run() {
system.out.println("执行============");
}
},1,2,timeunit.seconds); //单位是秒
}
自定义threadfactory
四种线程池的使用就说到这里了，值得说明的是，除了上面的参数外，executors类中还给这四种线程池提供了可传threadfactory的重载方法，以下是它们的源码：
public static executorservice newsinglethreadexecutor(threadfactory threadfactory) {
return new finalizabledelegatedexecutorservice
(new threadpoolexecutor(1, 1,
0l, timeunit.milliseconds,
new linkedblockingqueue<runnable>(),
threadfactory));
}
public static executorservice newcachedthreadpool(threadfactory threadfactory) {
return new threadpoolexecutor(0, integer.max_value,
60l, timeunit.seconds,
new synchronousqueue<runnable>(),
threadfactory);
}
public static scheduledexecutorservice newscheduledthreadpool(
int corepoolsize, threadfactory threadfactory) {
return new scheduledthreadpoolexecutor(corepoolsize, threadfactory);
}
public static executorservice newfixedthreadpool(int nthreads, threadfactory threadfactory) {
return new threadpoolexecutor(nthreads, nthreads,
0l, timeunit.milliseconds,
new linkedblockingqueue<runnable>(),
threadfactory);
}
threadfactory是一个接口类，也就是我们经常说的线程工厂，只有一个方法，可以用于创建线程：
thread newthread(runnable r);
默认情况下，threadpoolexecutor构造器传入的threadfactory 参数是executors类中的defaultthreadfactory()，相当于一个线程工厂，帮我们创建了线程池中所需的线程。
除此之外，我们也可以自定义threadfactory，并根据自己的需要来操作线程，下面是实例代码：
public static void main(string[] args) {
executorservice service = new threadpoolexecutor(5, 5, 0l, timeunit.milliseconds,
new synchronousqueue<runnable>(), new threadfactory() {
@override
public thread newthread(runnable r) {
thread t = new thread(r);
system.out.println("我是线程" + r);
return t;
}
}
);
//用lambda表达式编写方法体中的逻辑
runnable run = () -> {
try {
thread.sleep(1000);
system.out.println(thread.currentthread().getname() + "正在执行");
} catch (interruptedexception e) {
e.printstacktrace();
}
};
for (int i = 0; i < 5; i++) {
service.submit(run);
}
//这里一定要做关闭
service.shutdown();
}
运行代码后，控制行会输出五行 “我是线程java.util.concurrent.threadpoolexecutor。。。。。”的信息，也证明了我们自定义的threadfactory起到了作用。