工作中禁止使用Executors快捷创建线程池原理详解

目录

问题？1.1 newFixedThreadPool的潜在问题1.2 newSingleThreadExecutor的潜在问题？1.3 newCachedThreadPool的潜在问题1.4 newScheduledThreadPool 潜在问题1.5 总结

问题？

在很多公司（如阿里、华为等）的编程规范中，非常明确地禁止使用Executors快捷创建线程池，为什么呢？这里从源码讲起，介绍使用Executors工厂方法快捷创建线程池将会面临的潜在问题。

1.1 newFixedThreadPool的潜在问题

基本使用

1.          // 线程池
2.         ExecutorService singleThreadExecutor = Executors.newFixedThreadPool(2);
3.         // 批量添加线程
4.         for (int i = 0; i < 7; i++) {
5.             singleThreadExecutor.execute(new TargetTask());
6.             //  singleThreadExecutor.submit(new TargetTask());
7.         }
8.         Thread.sleep(1000);
9.         // 线程池销毁
10.         singleThreadExecutor.shutdown();;

复制代码

查看源码

1.   public static ExecutorService newFixedThreadPool(int nThreads) {
2.         return new ThreadPoolExecutor(nThreads, nThreads,
3.                                       0L, TimeUnit.MILLISECONDS,
4.                                       new LinkedBlockingQueue<Runnable>());
5.     }
6.     /**
7.      * Creates a {@code LinkedBlockingQueue} with a capacity of
8.      * {@link Integer#MAX_VALUE}.
9.      */
10.     public LinkedBlockingQueue() {
11.         this(Integer.MAX_VALUE);
12.     }

复制代码

我们可以看出：

corePoolSize(核心线程数)=maximumPoolSize（最大线程数）。LinkedBlockingQueue是一个无界队列，如果提交的任务过快会造成任务大量的的堆积，消耗完服务器资源。如果队列很大，很有可能导致JVM出现OOM（Out Of Memory）异常，即内存资源耗尽。

1.2 newSingleThreadExecutor的潜在问题？

基本使用

1.          // 线程池
2.         ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
3.         // 批量添加线程
4.         for (int i = 0; i < 5; i++) {
5.             singleThreadExecutor.execute(new TargetTask());
6.           //  singleThreadExecutor.submit(new TargetTask());
7.         }
8.         Thread.sleep(1000);
9.         // 线程池销毁
10.         singleThreadExecutor.shutdown();;

复制代码

查看源码

1.     public static ExecutorService newSingleThreadExecutor() {
2.         return new FinalizableDelegatedExecutorService
3.             (new ThreadPoolExecutor(1, 1,
4.                                     0L, TimeUnit.MILLISECONDS,
5.                                     new LinkedBlockingQueue<Runnable>()));
6.     }
7.    /**
8.      * Creates a {@code LinkedBlockingQueue} with a capacity of
9.      * {@link Integer#MAX_VALUE}.
10.      */
11.     public LinkedBlockingQueue() {
12.         this(Integer.MAX_VALUE);
13.     }

复制代码

尝试修改核心线程数

1. package ExecutorDemo.newSingleThreadExecutor;
2. import java.util.concurrent.ExecutorService;
3. import java.util.concurrent.Executors;
4. import java.util.concurrent.ThreadPoolExecutor;
5. /**
6. * @description:
7. * @author: shu
8. * @createDate: 2022/11/1 10:45
9. * @version: 1.0
10. */
11. public class UpdateSingleThreadExecutor {
12.     public static void main(String[] args) {
13.         //创建一个固定大小的线程池
14.         ExecutorService fixedExecutorService =
15.                 Executors.newFixedThreadPool(1);
16.         ThreadPoolExecutor threadPoolExecutor =
17.                 (ThreadPoolExecutor) fixedExecutorService;
18.         System.out.println(threadPoolExecutor.getMaximumPoolSize());
19.         //设置核心线程数
20.         threadPoolExecutor.setCorePoolSize(8);
21.         //创建一个单线程化的线程池
22.         ExecutorService singleExecutorService =
23.                 Executors.newSingleThreadExecutor();
24.         //转换成普通线程池，会抛出运行时异常 java.lang.ClassCastException
25.         ((ThreadPoolExecutor) singleExecutorService).setCorePoolSize(8);
26.     }
27. }

复制代码

我们可以看出：

单例存在，我们无法去修改核心线程数，否则会造成异常处理。corePoolSize(核心线程数)=maximumPoolSize（最大线程数）=1 。LinkedBlockingQueue是一个无界队列，如果提交的任务过快会造成任务大量的的堆积，消耗完服务器资源。如果队列很大，很有可能导致JVM出现OOM（Out Of Memory）异常，即内存资源耗尽。

1.3 newCachedThreadPool的潜在问题

基本使用

1.         // 线程池
2.         ExecutorService singleThreadExecutor = Executors.newCachedThreadPool();
3.         // 批量添加线程
4.         for (int i = 0; i < 7; i++) {
5.             singleThreadExecutor.execute(new TargetTask());
6.             //  singleThreadExecutor.submit(new TargetTask());
7.         }
8.         Thread.sleep(1000);
9.         // 线程池销毁
10.         singleThreadExecutor.shutdown();;

复制代码

源码分析

1.     public static ExecutorService newCachedThreadPool() {
2.         return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
3.                                       60L, TimeUnit.SECONDS,
4.                                       new SynchronousQueue<Runnable>());
5.     }
6.      * Creates a {@code SynchronousQueue} with nonfair access policy.
7.      */
8.     public SynchronousQueue() {
9.         this(false);
10.     }

复制代码

ThreadPoolExecutor标准构造器创建一个核心线程数为0、最大线程数不设限制的线程池理论上可缓存线程池可以拥有无数个工作线程，即线程数量几乎无限制。可缓存线程池的workQueue为SynchronousQueue同步队列，这个队列类似于一个接力棒，入队出队必须同时传递，正因为可缓存线程池可以无限制地创建线程，不会有任务等待，所以才使用SynchronousQueue。但是，maximumPoolSize的值为Integer.MAX_VALUE（非常大），可以认为可以无限创建线程，如果任务提交较多，就会造成大量的线程被启动，很有可能造成OOM异常，甚至导致CPU线程资源耗尽。

1.4 newScheduledThreadPool 潜在问题

基本使用

1.           // 线程池
2.         ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
3.         // 批量添加线程
4.         for (int i = 0; i < 7; i++) {
5.             ScheduledFuture<?> future = service.scheduleWithFixedDelay(new TargetTask(), 0, 500, TimeUnit.MILLISECONDS);
6.         }
7.         Thread.sleep(1000);
8.         // 线程池销毁
9.         service.shutdown();;

复制代码

源码分析

1.     public ScheduledThreadPoolExecutor(int corePoolSize) {
2.         super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
3.               new DelayedWorkQueue());
4.     }
5. static class DelayedWorkQueue extends AbstractQueue<Runnable>
6.         implements BlockingQueue<Runnable> {
7.         private static final int INITIAL_CAPACITY = 16;
8.         private RunnableScheduledFuture<?>[] queue =
9.             new RunnableScheduledFuture<?>[INITIAL_CAPACITY];
10.         private final ReentrantLock lock = new ReentrantLock();
11.         private int size = 0;
12.         private Thread leader = null;
13.         private final Condition available = lock.newCondition();
14.         }

复制代码

maximumPoolSize为Integer.MAX_VALUE，表示线程数不设上限，其workQueue为一个DelayedWorkQueue实例，这是一个按到期时间升序排序的阻塞队列。

1.5 总结

虽然Executors工厂类提供了构造线程池的便捷方法，但是对于服务器程序而言，大家应该杜绝使用这些便捷方法，而是直接使用线程池ThreadPoolExecutor的构造器，从而有效避免由于使用无界队列可能导致的内存资源耗尽，或者由于对线程
以上就是工作中禁止使用Executors快捷创建线程池原理详解的详细内容，更多关于禁止用Executors创建线程池的资料请关注中国红客联盟其它相关文章！