Executor多线程框架学习笔记（二）：线程池初始化参数和ThreadPoolExecutor

目录

ThreadPoolExecutor

Executors和ThreadPoolExecutor的关系

拒绝策略

如何计算线程池中线程的数量

CPU密集型应用

IO密集型应用

---

ThreadPoolExecutor

构造方法：

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
        //maxmumPoolSize必须大于或等于1，也要大于或等于corePoolSize（第一处）
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        //第二处
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

构造方法的参数：

 

• corePoolSize：常驻核心线程数。这个值相当于线程池中即使没有请求时会保留的线程数。这个值设置的过大会浪费资源，设置的过小会频繁的创建和销毁线程。
• maximumPoolSize：线程池能够容纳同时执行的最大线程数。如果待执行的线程数大于该值，那么需要借助第五个参数，缓存在队列中。如果corePoolSize和maximumPoolSize相等，即是固定大小的线程池。
• keepAliveTime：当线程池中的线程数大于corePoolSIze时，空闲时间达到keepAliveTime后会销毁多余的线程。当allowCoreThreadTimeOut设置为true时，核心线程超时也会被回收。
• TimeUnit：表示时间单位。
• workQueue：缓存队列。当请求的线程数大于maximumPoolSize时，线程会进入BlockingQueue阻塞队列。使用锁来控制入队和出队的原子性。两个锁分别控制元素的添加和获取，是一个生产消费模型队列。
• threadFactory：线程工厂。用来生产一组任务相同的线程，线程池的命名时通过给factory来增加组名前缀来实现的。
• handler：执行拒绝策略的对象。当超过workQueue的任务缓存上限时，就可以通过该策略处理请求。是一种简单的限流防护。友好的拒绝策略可以是以下这些：
  • 保存到数据库进行削峰填谷，空闲时再提取出来执行。
  • 转向某个提示页面
  • 打印日志

Executors和ThreadPoolExecutor的关系

从构造方法的参数来开，队列，线程工厂，拒绝处理服务都必须有实例对象，但是实际使用线程池的时候很少有人自己实例化这三个对象，而是通过Executors线程池静态工厂提供默认实现。

 

Executor接口

public interface Executor {

    /**
     * Executes the given command at some time in the future.  The command
     * may execute in a new thread, in a pooled thread, or in the calling
     * thread, at the discretion of the {@code Executor} implementation.
     *
     * @param command the runnable task 线程任务
     * @throws RejectedExecutionException if this task cannot be
     * accepted for execution 如果无法创建任何状态的线程任务
     * @throws NullPointerException if command is null
     */
    void execute(Runnable command);
}

ExecutorService接口继承了Executor接口，定义了管理线程任务的方法。

ExecutorService的抽象类AbstractExecutorService提供了submit()、invokeAll()等部分方法的实现，但是核心方法Executor.excute()并没有实现。因为所有的任务都会在这个方法里执行，不同的实现会带来不同的执行策略。

可以看出线程池工厂类的设计采用了模板方法设计模式，父类定义相同的部分，子类实现不同的部分。

通过 Executors 的静态工厂方法可以创建三个线程池的包装对象：

ForkJoinPool

Executors.newWorkStealingPool: JDK8 引人，创建持有足够线程的线程池支持给定的并行度， 并通过使用多个队列减少竞争 此构造方法中把CPU 数量设置为默认的并行度。

public static ExecutorService newWorkStealingPool(int parallelism) {
        return new ForkJoinPool
            (parallelism,
             ForkJoinPool.defaultForkJoinWorkerThreadFactory,
             null, true);
    }

 

ThreadPooIExecutor

Executors.newFixedThreadPool : 输入的参数即是固定线程数，既是核心线程数也是最大线程数，不存在空闲线程，所以 keepAliveTime 等于0。这里的队列没有指明长度，如果瞬间请求非常大，会有 OOM 的风险。

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

Executors.newCachedThreadPool: maximumPoolSize最大可以至 Integer.MAX_VALUE，是高度可伸缩的线程池 ,如果达到这个上限 ,肯定会抛出 OOM 异常。 keepAlivTime 默认为 60 秒，工作线程处于空闲状态，则回收工作线程。如果任务数增加，再次创建出新线程，处理任务。

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

Executors.newFixedThreadPool :输入的参数即是固定线程数，既是核心线程数也是最大线程数，不存在空闲线程，所以 keepAliveTime 等于 0.

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

 

ScheduledThreadPoolExecutor

Executors.newScheduledThreadPool ：最大可以至 Integer.MAX_VALUE，支持定时及周期性任务执行。相对于Timer，ScheduedExecutorService更安全,功能更强大newCachedThreadPool的区别是不回收工作线程。

除 newWorkStealingPool 其他创建方式都存在资源耗尽的风险。

拒绝策略

实现RejectedExecutionHandler接口，重写rejectedExecution方法。

ThreadPoo!Executor中提供了四个公开的内部静态类提供四种拒绝策略。

AbortPolicy（默认）：丢弃任务并抛出 RejectedExecutionException 异常。

DiscardPolicy:丢弃任务，但是不抛出异常。

DiscardOldestPolicy:抛弃队列中等待最久的任务 然后把当前任务加入队 列中。

CallerRunsPolicy ：调用任务的run()方法绕过线程池直接执行。

如何计算线程池中线程的数量

CPU密集型应用

多线程并不会加快运算速度，并且线程切换和线程同步都会消耗额外CPU资源，所以线程池大小设置为N+1；

IO密集型应用

IO包括网络IO和磁盘IO，在发生IO的期间，CPU使用率并不高，因此可以让CPU在等待IO的时候去处理别的任务，充分利用CPU资源。线程池大小设置为2N+1；