final ExecutorService executor = new ThreadPoolExecutor(
        1, // corePoolSize
        3, // maximumPoolSize
        1, // keepAliveTime
        TimeUnit.SECONDS, // unit
        new ArrayBlockingQueue<>(1) // workQueue
        );
for (int i = 0; i < 5; i++) {
    final int index = i;
    try {
        executor.execute(() -> {
            println(index + " started...");
            sleep(2000);
            println(index + " stopped.");
        });
    } catch (RejectedExecutionException e) {
        println(index + " rejected: " + e.getMessage());
    }
}
executor.shutdown();
while (!executor.awaitTermination(1, TimeUnit.SECONDS)) {
    // No ops
}

// 必须对 ThreadPoolExecutor 调用 allowCoreThreadTimeOut 方法将同名参数设为 true 才会启用 keepAliveTime 检查
// wc 为工作线程数量，因此只有大于 corePoolSize 才会检查，因为只有超过核心运行线程数量的线程才会被当成多余的线程
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;

if ((wc > maximumPoolSize || (timed && timedOut))
    && (wc > 1 || workQueue.isEmpty())) {
    if (compareAndDecrementWorkerCount(c)) // [2] 回收多余线程，减少工作线程数量
        return null;
    continue;
}

try {
    Runnable r = timed ?
        workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
        workQueue.take();
    if (r != null)
        return r;
    timedOut = true; // [1] 在 keepAliveTime 内没有任务，则置为 true
} catch (InterruptedException retry) {
    timedOut = false;
}

this.keepAliveTime = unit.toNanos(keepAliveTime);

public static ThreadFactory defaultThreadFactory() {
    return new DefaultThreadFactory();
}

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); // 默认线程优先级是 NORM
    return t;
}

ExecutorService executor1 = Executors.newSingleThreadExecutor();
ExecutorService executor2 = Executors.newSingleThreadExecutor();
executor1.execute(() -> println("executor 1 thread 1"));
executor2.execute(() -> println("executor 2 thread 1"));
executor2.execute(() -> println("executor 2 thread 2"));
executor1.shutdown();
executor2.shutdown();

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

private static final RejectedExecutionHandler defaultHandler =
    new AbortPolicy();

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

private static final List<Integer> DATA = prepareData();

private static List<Integer> prepareData() {
    final List<Integer> data = new ArrayList<>();
    for (int i = 0; i < 100000; i++) {
        data.add(i);
    }
    return data;
}

public static void main(String[] args) throws InterruptedException, ExecutionException {
    final int numThreads = 5;
    final int sizePerThread = DATA.size() / numThreads;
    final List<Future<Long>> futures = new ArrayList<>();
    final ExecutorService executor = Executors.newFixedThreadPool(numThreads);
    for (int i = 0; i < numThreads; i++) {
        final int startIndex = i * sizePerThread;
        final int endIndex = (i < numThreads - 1) ? (startIndex + sizePerThread) : DATA.size();
        futures.add(executor.submit(() -> {
            long sum = 0;
            for (int j = startIndex; j < endIndex; j++) {
                sum += DATA.get(j);
            }
            return sum; // 该 lambda 返回 Long，对应 Callable<Long>，因此 submit 返回的是 Future<Long>
        }));
    }
    long sum = 0;
    for (Future<Long> future : futures) {
        sum += future.get();
    }
    System.out.println(sum);
    executor.shutdown();
}