线程池ThreadPoolExecutor--Executors.newFixedThreadPool()

最新推荐文章于 2025-09-18 15:02:20 发布

原创最新推荐文章于 2025-09-18 15:02:20 发布 · 4k 阅读

6 ·

CC 4.0 BY-SA版权

Java 专栏收录该内容

9 篇文章

订阅专栏

本文深入探讨了线程池ThreadPoolExecutor的工作原理，分析了使用Executors创建线程池的潜在风险，尤其是OOM问题。建议手动配置线程池参数，以避免资源耗尽。

线程池ThreadPoolExecutor

我们可以使用Executor工厂类Executors快速的获取一个ThreadPoolExecutor

   ExecutorService executorService = Executors.newFixedThreadPool(10);

但是如果我们安装了Alibaba Java Coding Guidelines插件会提示我们

线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这
样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。
说明：Executors 返回的线程池对象的弊端如下：
1） FixedThreadPool 和 SingleThreadPool：
允许的请求队列长度为 Integer.MAX_VALUE，可能会堆积大量的请求，从而导致 OOM。
2） CachedThreadPool：
允许的创建线程数量为 Integer.MAX_VALUE，可能会创建大量的线程，从而导致 OOM。

那么为什么不允许使用Executors去创建呢？首先看newFixedThreadPool方法的实现

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

可以看出创建了一个ThreadPoolExecutor类，核心线程池数量和最大线程池数量都是我们初始化的值，但是要注意阻塞队列使用的是new LinkedBlockingQueue() 是一个链表阻塞队列，再去看看链表阻塞队列的构造方法

	public LinkedBlockingQueue() {
        this(Integer.MAX_VALUE);
    }
    public LinkedBlockingQueue(int capacity) {
        if (capacity <= 0) throw new IllegalArgumentException();
        this.capacity = capacity;
        last = head = new Node<E>(null);
    }

链表的长度达到了默认的Integer的最大值。而再看看ThreadPoolExecutor的execute方法

 /*
         * Proceed in 3 steps:
         *
         * 1. If fewer than corePoolSize threads are running, try to
         * start a new thread with the given command as its first
         * task.  The call to addWorker atomically checks runState and
         * workerCount, and so prevents false alarms that would add
         * threads when it shouldn't, by returning false.
         *
         * 2. If a task can be successfully queued, then we still need
         * to double-check whether we should have added a thread
         * (because existing ones died since last checking) or that
         * the pool shut down since entry into this method. So we
         * recheck state and if necessary roll back the enqueuing if
         * stopped, or start a new thread if there are none.
         *
         * 3. If we cannot queue task, then we try to add a new
         * thread.  If it fails, we know we are shut down or saturated
         * and so reject the task.
         */
		int c = ctl.get();
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            if (! isRunning(recheck) && remove(command))
                reject(command);
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        else if (!addWorker(command, false))
            reject(command);