记一次ThreadPoolExecutor面试

ThreadPoolExecutor点滴

线程池应该也是面试绕不开的一个点，平时你们也没少用，但其实也有一些小Tips仍是值得记录一下。

Constructor

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

• corePoolSize-线程池中保留的线程数量——尽管空闲（若是allowCoreThreadTimeOut被调用或者设置，在达到keepAliveTime后会销毁）
• maximumPoolSize-线程池中容许的最大线程数量
• keepAliveTime-线程数量超过核心线程数，超出的空闲线程最大存活时间
• unit-存活时间单位
• workQueue-任务队列，只接受经过execute方法提交的任务，最好自定义队列为有界队列，不然默认是Integer.MAX_VALUE（2147483647），内存会被挤压的任务压爆
• threadFactory-线程建立工厂（一个接口），默认是Executors.defaultThreadFactory()，能够设置线程的名字（好比设置更有业务含义的名字，方便定位问题），是不是守护线程，设置优先级等
• handler-拒绝策略handler，默认的有4个：1. 直接拒绝抛出异常；2. 交给提交线程来执行；3. 丢弃最旧提交可是没有执行的任务；4. 直接丢弃

一个任务提交到线程池的执行流程以下：

1. 当前活动线程小于核心线程数，直接新起线程运行
2. 当前活动线程大于核心线程数，入阻塞任务队列
3. 当前活动线程大于核心线程数，阻塞任务队列已满，检查活动线程是否达到最大线程数，没有则新开一个线程，不然执行拒绝策略

线程池的状态

注意是线程池的状态而非池中处理任务线程的状态，代码中用一个int来存放线程池的状态（高三位）和活动线程数（低29位）。

• RUNNING(-1<<29)：能够接受新任务和处理队列中的任务
• SHUTDOWN(0<<29)：不接受新的任务，但会继续处理队列中的任务
• STOP(1<<29): 不接受新的任务，也不继续处理队列中的任务，且会打断正在处理中的任务
• TIDYING(2<<29)：全部的任务都terminated，worker数是0，线程转移到该状态会运行terminated()钩子方法
• TERMINATED(3<<29): terminated()执行完毕

状态之间的转移：

• RUNNING -> SHUTDOWN, shutdown()被显示调用
• (RUNNING OR SHUTDOWN) -> STOP, shutdownNow()被显示调用
• SHUTDOWN -> TIDYING, 队列和池都空
• STOP -> TIDYING, 池空
• TIDYING -> TERMINATED, terminated()执行完毕

// 主线程池控制状态(control state)ctl，把workerCount和runState聚到到一个变量中，runStateOf/workerCountOf获得当前线程的状态和运行数
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
private static final int CAPACITY   = (1 << 29) - 1;
// c就是ctl
// 获得高3位
private static int runStateOf(int c)     { return c & ~CAPACITY; }
// 获得低29位
private static int workerCountOf(int c)  { return c & CAPACITY; }
private static int ctlOf(int rs, int wc) { return rs | wc; }

几个容易被忽略的API

在面试中被问到过一次这样的问题：想让线程池在初始化时就干活，而不是等到第一次提交任务时才建立线程，该怎么作？

这个问题在实际中应该是存在的，毕竟线程的建立是有开销的，既然建立了线程池确定是为了用，也就不存在须要延迟建立之类的需求，不如在系统启动时就将线程池中的线程建立好，这样来了任务就能够直接交由线程处理。

翻看线程池的doc，能够看到有这样两个方法

/**
* Starts a core thread, causing it to idly wait for work. This overrides the default policy of starting core threads only when new tasks are executed. This method will return false if all core threads have already been started.
*/
public boolean prestartCoreThread() {
    return workerCountOf(ctl.get()) < corePoolSize &&
        addWorker(null, true);
}

/**
Starts all core threads, causing them to idly wait for work. This overrides the default policy of starting core threads only when new tasks are executed.
*/
public int prestartAllCoreThreads() {
    int n = 0;
    while (addWorker(null, true))
        ++n;
    return n;
}

从源代码能够发现两个方法默认的策略是只有第一个任务到达时才会建立线程，能够覆盖这两个方法，而后在建立线程池时调用，就能够达到目的。

@Override
public boolean prestartCoreThread() {
    execute(() -> System.out.println("start a core thread"));
    return true;
}

@Override
public int prestartAllCoreThreads() {
    int n = 0;
    while (++n < coreSize) {
        execute(() -> System.out.println("start a core thread"));
    }
    return n;
}

此外还有两个hook方法：beforeExecute和afterExecute，也能够经过覆盖这两个方法，在一个task执行的先后作一些事情。

/**
t - the thread that will run task r
r - the task that will be executed
*/
@Override
protected void beforeExecute(Thread t, Runnable r) {
    System.out.println("---before log---");
    super.beforeExecute(t, r);
}

/**
r - the runnable that has completed
t - the exception that caused termination, or null if execution completed normally
*/
@Override
protected void afterExecute(Runnable r, Throwable t) {
    super.afterExecute(r, t);
    System.out.println("---after log---");
}

END

固然线程池还有其余不少知识点，鉴于大多数的文章都会涉及到我也不在赘述了，这两个扩展点平时中用到的比较少，因此权当笔记和扩展一点本身的知识点，不管是面试仍是实践，感受按照场景来都有些许用处。