谈谈为什么禁止使用Executors创建线程池?
首先, 可以通过Executors静态工厂构建线程池,但是一般不建议这样使用。
什么是Executors?
Executors是一个Java中的工具类。提供工厂方法来创建不同类型的线程池。如下所示:
从源码中可知,Executors的创建线程池的方法,创建出来的线程池都实现了ExecutorService接口。常用方法有以下几个:
- newFixedThreadPool(int nThreads):创建固定数目线程的线程池。
- newCachedThreadPool():创建一个可缓存的线程池,调用execute将重用以前构造的线程(如果线程可用)。如果没有可用的线程,则创建一个新线程并添加到线程池中。终止并从缓存中移除那些已有60秒钟未被使用的线程。
- newSingleThreadExecutor():创建一个单线程化的Executor。
- newScheduledThreadPool(int corePoolSize):创建一个支持定时及周期性的任务执行的线程池,多数情况下可用来替代Timer类。
从源码看,该类的功能还是非常强大的,而且还用到了工厂模式,具有比较强的扩展性,用起来也方便,例如:
ExecutorService executor = Executors.newFixedThreadPool(nThreads);
即可创建一个固定大小的线程池。
但是:在开发中不允许使用Executors去创建线程池,而是通过ThreadPoolExecutor的方式,这样可以避免资源耗尽的风险。原因是:
- FixedThreadPool和SingleThreadPool:允许的请求队列长度为Integer.MAX_VALUE,可能会堆积大量的请求,从而导致OOM。
- CachedThreadPool和ScheduledThreadPool:允许的创建线程数量为Integer.MAX_VALUE,可能会创建大量的线程,从而导致OOM。
Executors存在什么问题?
首先看一个简单的例子,模拟Executors导致OOM的情况:
package com.seckill.secondkill;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ExecutorsDemo {
private static ExecutorService executor = Executors.newFixedThreadPool(15);
public static void main(String[] args) {
for (int i = 0; i < Integer.MAX_VALUE; i++) {
executor.execute(new SubThread());
}
}
}
class SubThread implements Runnable{
@Override
public void run() {
try{
Thread.sleep(10000);
}catch (InterruptedException e){
// do nothing
e.printStackTrace();
}
}
}
指定JVM运行参数:-Xmx8m -Xms8m, 然后运行代码,会抛出OOM:
上面异常表示在main函数的线程中存在未捕获的异常。
Executors为什么存在缺陷?
我们分析newFixedThreadPool的底层源码,真正导致OOM的其实是LinkedBlockingQueue.offer
方法:
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
这里补充Java中的阻塞队列的知识:
Java中的BlockingQueue
主要有两种实现,分别是ArrayBlockingQueue
和LinkedBlockingQueue
。
- ArrayBlockingQueue是一个用数组实现的有界阻塞队列,必须设置容量。
- LinkedBlockingQueue是一个用链表实现的有界阻塞队列,容量可以选择进行设置,不设置的话,将是一个无边界的阻塞队列,最大长度为Integer.MAX_VALUE.
因此,这里就出现了一个问题:如果我们不设置 LinkedBlockingQueue 的容量的话,其默认容量将会是 Integer.MAX_VALUE。而newFixedThreadPool中创建LinkedBlockingQueue时,并未指定容量。此时,LinkedBlockingQueue就是一个无边界队列,对于一个无边界队列来说,是可以不断的向队列中加入任务的,这种情况就有可能因为任务过多导致内存溢出问题。
上面提到的问题主要体现在 newFixedThreadPool
和 newSingleThreadExecutor
两个工厂方法上,并不是说 newCachedThreadPool 和 newScheduledThreadPool 这两个方法就安全了,这两种方式创建的最大线程数可能是 Integer.MAX_VALUE,而创建这么多线程,必然就有可能导致 OOM。
如何正确创建线程池?
避免使用Executors创建线程池,主要是避免使用其中的默认实现。我们可以自己直接调用ThreadPoolExecutor的构造函数来自己创建线程池,在创建的同时,给BlockQueue指定容量就可以。
private static ExecutorService executor =
new ThreadPoolExecutor(10,10,60L, TimeUnit.SECONDS, new ArrayBlockingQueue<>(10));
这种情况下,一旦提交的线程数超过当前可用线程数时,就会抛出java.util.concurrent.RejectedExecutionException,这是因为当前线程池使用的队列是有界队列,队列已经满了便无法继续处理新的请求。但是异常(Exception)总比错误好。
当然,除了自己定义ThreadPoolExecutor外,还可以使用一些开源类库,比如apache
和guava
等。这里推荐使用guava提供的ThreadFactoryBuilder来创建线程池。示例如下:
package com.seckill.secondkill;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.apache.tomcat.util.threads.ThreadPoolExecutor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;
public class ExecutorsDemo {
private static ThreadFactory namedThreadFactory = new ThreadFactoryBuilder()
.setNameFormat("demo-pool-%d").build();
private static ExecutorService pool = new ThreadPoolExecutor(5, 100,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>(1024), namedThreadFactory, new ThreadPoolExecutor.AbortPolicy());
public static void main(String[] args) {
for (int i = 0; i < Integer.MAX_VALUE; i++) {
pool.execute(new SubThread());
}
System.out.println("END");
}
}
class SubThread implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getState() + "----------" + Thread.currentThread().getName());
}
}
执行过程中的线程数:
通过上述方式创建线程时,不仅可以避免 OOM 的问题,还可以自定义线程名称,更加方便的出错的时候溯源。