并发编程学习笔记（三十二、线程池源码二，ThreadPoolExecutor构造函数）

目录：

• corePoolSize：核心线程数量
• workQueue：阻塞队列
• maximumPoolSize：最大线程数量
• threadFactory：线程工厂
• handler：拒绝、饱和策略
• 线程池执行原理图

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) {
}

可参考之前的一篇文章：https://www.cnblogs.com/bzfsdr/p/13089015.html

corePoolSize：核心线程数量

corePoolSize：核心线程数量。

• 核心线程将一直保存在线程池中，哪怕是处于空闲状态也可以不回收，当然你也可以通过allowCoreThreadTimeOut参数控制是否回收核心线程。
• 刚创建线程池的时候，核心线程并不会立即启动，而是等到有任务提交时才会启动（preStartCoreThread、preStartAllCoreThreads方法可以预启动核心线程，以提升效率）。

workQueue：阻塞队列

• BlockingQueue接口所有的实现类都可以作为阻塞队列（如之前学的ArrayBlockingQueue、LinkedBlockingQueue）。
• 设置阻塞队列容量时需要注意一点：最好不要设置无界的阻塞队列，因为这样的话即使核心线程是处于工作状态时也会无限制的接收其它任务，导致队列过程，影响JVM性能，严重情况下可能会造成OOM（这也是Alibaba不推荐使用Executors类来直接创建线程池的原因）。

maximumPoolSize：最大线程数量

• 当阻塞队列已满还有新的任务进来时，就会去创建非核心线程来执行任务，当然这也是有限制的，也就是不能超过maximumPoolSize。
• 非核心线程会被回收，通过keepAliveTime、unit控制空闲回收条件。

threadFactory：线程工厂

用于定线程初始化的创建工程，默认实现为DefaultThreadFactory。

static class DefaultThreadFactory implements ThreadFactory {
    private static final AtomicInteger poolNumber = new AtomicInteger(1);
    private final ThreadGroup group;
    private final AtomicInteger threadNumber = new AtomicInteger(1);
    private final String namePrefix;

    DefaultThreadFactory() {
        SecurityManager s = System.getSecurityManager();
        group = (s != null) ? s.getThreadGroup() :
                              Thread.currentThread().getThreadGroup();
        namePrefix = "pool-" +
                      poolNumber.getAndIncrement() +
                     "-thread-";
    }

    public Thread newThread(Runnable r) {
        Thread t = new Thread(group, r,
                              namePrefix + threadNumber.getAndIncrement(),
                              0);
        if (t.isDaemon())
            t.setDaemon(false);
        if (t.getPriority() != Thread.NORM_PRIORITY)
            t.setPriority(Thread.NORM_PRIORITY);
        return t;
    }
}

其实现也很简单，定义了线程组和守护线程、优先级等东西。

当然你也可以通过实现ThreadFactory接口自定义线程工厂：

/**
 * 线程工厂
 */
static class NameTreadFactory implements ThreadFactory {
    /** 线程id **/
    private final AtomicInteger threadId = new AtomicInteger(1);

    @Override
    public Thread newThread(Runnable runnable) {
        Thread t = new Thread(runnable, "线程-" + threadId.getAndIncrement());
        System.out.println(t.getName() + " 已经被创建");
        return t;
    }
}

handler：拒绝、饱和策略

当线程池数量达到最大，并且阻塞队列的容量也达到最大的时候，线程池将达到最大负载；此时再往线程池添加任务时，线程池将无法继续处理。二拒绝策略就是为了保护线程池的负载。

ThreadPoolExecutor默认提供了4中策略，如果你还觉得不过瘾就可以实现RejectedExecutionHandler接口构建自己的策略。

1、直接运行（若线程池还未关闭，直接运行被拒任务）：CallerRunsPolicy。

public static class CallerRunsPolicy implements RejectedExecutionHandler {
    public CallerRunsPolicy() { }
    
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        if (!e.isShutdown()) {
            r.run();
        }
    }
}

2、不接受处理（抛出RejectedExecutionException异常）：AbortPolicy。

public static class AbortPolicy implements RejectedExecutionHandler {
    public AbortPolicy() { }

    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        throw new RejectedExecutionException("Task " + r.toString() +
                                             " rejected from " +
                                             e.toString());
    }
}

3、啥都不做：DiscardPolicy。

public static class DiscardPolicy implements RejectedExecutionHandler {
    public DiscardPolicy() { }

    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
    }
}

4、取舍：（舍弃最早进入队列的任务，然后执行新的任务）：DiscardOldestPolicy。

public static class DiscardOldestPolicy implements RejectedExecutionHandler {
    public DiscardOldestPolicy() { }

    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        if (!e.isShutdown()) {
            e.getQueue().poll();
            e.execute(r);
        }
    }
}

5、自定义

/**
 * 线程池拒绝策略
 */
public static class MyIgnorePolicy implements RejectedExecutionHandler {

    @Override
    public void rejectedExecution(Runnable runnable, ThreadPoolExecutor e) {
        doLog(runnable, e);
    }

    private void doLog(Runnable runnable, ThreadPoolExecutor e) {
        // 可做日志记录等等
        System.err.println(runnable.toString() + " rejected");
    }
}

线程池执行原理图