Executors：为什么阿里不待见我？

三分恶

发布于 2021-11-15 15:44:57

5780

发布于 2021-11-15 15:44:57

文章被收录于专栏：三分恶的专栏三分恶的专栏

大家好，我是Excutors，一个老实的工具类。

有个叫老三的程序员在文章要是以前有人这么讲线程池，我早就该明白了！里挖了一个坑，说要把我介绍给大家认识认识。

我其实挺委屈的，作为一个没得感情，老实干活的工具类，我却上了阿里巴巴的黑名单。他们在一本叫《Java开发手册》的册子里写道：

作者画外音：人家为啥给你拉黑，不写的清清楚楚嘛，你有啥可委屈的。而且你这个家伙就是表面看起来老实，活是你干的吗？干活的不都是小老弟ThreadPoolExecutor。来，我一个个给你数。

1. newFixedThreadPool

FixedThreadPool,是一个固定大小的线程池。

看一下它的源代码实现：

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

直接调用ThreadPoolExecutor的构造方法。

核心线程数和最大线程数相同
使用LinkedBlockingQueue作为任务队列

FixedThreadPool的execute()运行示意图：

整体运行过程：

当前运行线程少于corePoolSize，则创建新线程执行任务
当前运行线程大于corePoolSize，将任务加入LinkedBlockingQueue
线程池中线程执行完任务后，会循环从LinkedBlockingQueue中获取任务执行

因为使用无界队列LinkedBlockingQueue来存储不能执行的任务，所以不会触发拒绝服务策略，可能会导致OOM。

2. newSingleThreadExecutor

SingleThreadExecutor是使用单个线程工作的线程池。

实现源码如下：

    public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

直接调用ThreadPoolExecutor的构造方法。

核心线程数和最大线程数都是1
使用LinkedBlockingQueue作为任务队列

SingleThreadExecutor的运行流程：

当前无运行线程，创建一个线程来执行任务
当前有线程运行，将任务加入LinkedBlockingQueue
线程执行完任务后，会循环从LinkedBlockingQueue中获取任务来执行

这里用了无界队列LinkedBlockingQueue，同样可能会导致OOM。

3. newCachedThreadPool

CachedThreadPool是一个会根据需要创建新线程的线程池。

实现源码：

    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

直接调用ThreadPoolExecutor的构造方法。

核心线程数为0，最大线程数是非常大的一个数字Integer.MAX_VALUE
使用没有容量的SynchronousQueue作为工作队列
keepAliveTime设置为60L，空闲线程空闲60秒之后就会被终止

CachedThreadPool的运行流程：

如果当前有空闲线程，使用空闲线程来执行任务
如果没有空闲线程，创建一个新线程来执行任务
新建的线程执行完任务后，会执行poll（keepAliveTime，TimeUnit.NANOSECONDS）,在SynchronousQueue里等待60s

这里线程池的大小没有限制，可能会无限创建线程，导致OOM。

4. newScheduledThreadPool

ScheduledThreadPool是一个具备调度功能的线程池。

实现源码：

    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }

可以看到，这个线程池不太一样，它调用的是ScheduledThreadPoolExecutor的构造方法。

    public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue());
    }

最大线程数是Integer.MAX_VALUE，无限大
使用DelayedWorkQueue作为任务队列

ScheduledThreadPoolExecutor执行任务的流程：

主要分为两大部分：

调用scheduleAtFixedRate()/scheduleWithFixedDelay()方法，会向DelayQueue添加一个ScheduledFutureTask。
线程池的线程从DelayQueue中获取ScheduledFutureTask，然后执行任务。

它同样可以无限创建线程，所以也存在OOM的风险。

为了实现周期性执行任务，ScheduledThreadPoolExecutor对ThreadPoolExecutor进行了一些改造[4]：

ScheduledFutureTask来作为调度任务的实现它主要包含了3个成员变量time(任务将要被执行的具体时间)、sequenceNumber（任务的序号）、period(任务执行的间隔周期)
使用DelayQueue作为任务队列 DelayQueue封装了了一个PriorityQueue，会对对队列中的ScheduledFutureTask进行排序，排序的优先级time>sequenceNumber。