可设置的主要参数

corePoolSize

核心线程数，核心线程会一直存活，即使没有任务需要处理。当线程数小于核心线程数时，即使现有的线程空闲，线程池也会优先创建新线程来处理任务，而不是直接交给现有的线程处理。

核心线程在allowCoreThreadTimeout被设置为true时会超时退出，默认情况下不会退出。

maxPoolSize

当线程数大于或等于核心线程，且任务队列已满时，线程池会创建新的线程，直到线程数量达到maxPoolSize。如果线程数已等于maxPoolSize，且任务队列已满，则已超出线程池的处理能力，线程池默认会拒绝处理任务而抛出异常。可以自定义处理多余任务的RejectedExecutionHandler

该参数在某些情况下是无效的。

keepAliveTime

当已经执行过的线程空闲后，空闲时间小于keepAliveTime，又来了新的任务时，会直接启动该线程。

当线程空闲时间达到keepAliveTime，该线程会退出，直到线程数量等于corePoolSize。

如果allowCoreThreadTimeout设置为true，则所有线程均会退出直到线程数量为0。

allowCoreThreadTimeout

是否允许核心线程空闲退出，默认值为false。

queueCapacity

任务队列容量，由它设定一个有界的队列。从maxPoolSize的描述上可以看出，任务队列的容量会影响到线程的变化，因此任务队列的长度也需要恰当的设置。

RejectedExecutionHandler

public interface RejectedExecutionHandler {
  void rejectedExecution(Runnable r, ThreadPoolExecutor executor);
}

任务拒绝处理策略。在源码中定义了如下几种策略：

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());
        }
    }

该策略直接抛出了异常。异常中止

CallerRunsPolicy

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

在线程池未关闭时，直接在当前线程执行任务。所谓当前线程，即提交任务时的线程

DiscardPolicy

public static class DiscardPolicy implements RejectedExecutionHandler {
    public DiscardPolicy() { }
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
    }
}

不做任何处理，即跳过任务r

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);
        }
    }
}

在线程池未关闭时，移除处于队头的任务，再执行任务r。相当于把之前队头的任务跳过了，把r又加入了队列

参数对线程池任务调度的影响

当任务数大于等于corePoolSize，这时，除核心线程执行了一定数量的任务后，

余下的需要执行的任务数为int count = tasksCount - corePoolSize，设队列最大容量为capacity：

若capacity >= count，则只会创建corePoolSize个线程来执行任务。多的任务放在队列中。
这时maxPoolSize，就无效了
若capacity < count，这时有int remain = tasksCount - capacity：
- 若 remain <= maxPoolSize，创建remain个线程来执行任务。多的任务放在队列中
- 若remain > maxPoolSize，创建maxPoolSize个线程来执行任务；这时将有remain-maxPoolSize个任务无法加入队列，被RejectedExecutionHandler处理。

Executors生成ThreadPoolExecutor

(most from http://dongxuan.iteye.com/blog/901689)

在构建时，corePoolSize、maximumPoolSizes 和BlockingQueue的选择，直接影响线程调度的策略

Executors 有三个方法可以生成 ThreadPoolExecutor

生成一个固定线程数的 ThreadPoolExecutor

public static ExecutorService newFixedThreadPool(int nThreads) {

return new ThreadPoolExecutor(nThreads, nThreads,

0L, TimeUnit.MILLISECONDS,

new LinkedBlockingQueue());

}

LinkedBlockingQueue实现是线程安全的，实现了先进先出等特性，是作为生产者消费者的首选，LinkedBlockingQueue 可以指定容量，也可以不指定，不指定的话，默认最大是Integer.MAX_VALUE，其中主要用到put和take方法，put方法在队列满的时候会阻塞直到有队列成员被消费，take方法在队列空的时候会阻塞，直到有队列成员被放进来。在ThreadPoolExecutor中主要使用的是BlockingQueue的offer()和 poll()、take()

LinkedBlockingQueue 无界队列

生成一个只含一个线程的ThreadPoolExecutor

public static ExecutorService newSingleThreadExecutor() {

return new FinalizableDelegatedExecutorService

(new ThreadPoolExecutor(1, 1,

0L, TimeUnit.MILLISECONDS,

new LinkedBlockingQueue()));

}

LinkedBlockingQueue 无界队列

生成一个无界的并直接提交的ThreadPoolExecutor

public static ExecutorService newCachedThreadPool() {

return new ThreadPoolExecutor(0, Integer.MAX_VALUE,

60L, TimeUnit.SECONDS,

new SynchronousQueue());

}

这个线程池根据需要（新任务到来时）创建新的线程，如果有空闲线程则会重复使用，线程空闲了60秒后会被回收

SynchronousQueue 的特点是，每个插入操作必须等待另一个线程的对应移除操作。比如，要添加一个元素，接下来如果继续想尝试添加则会阻塞，直到另一个线程取走一个元素，反之亦然

SynchronousQueue 不会保留任务进队列，会直接提交到工作线程。

如果当前没有可工作线程，那么在 corePoolSize

关于工作队列(workQueue)：

所有 BlockingQueue 都可用于传输和保持提交的任务。可以使用此队列与池大小进行交互：

如果运行的线程少于 corePoolSize，则 Executor 始终首选添加新的线程，而不进行排队。（什么意思？如果当前运行的线程小于corePoolSize，则任务根本不会存放，添加到queue中，而是直接开始运行thread。
如果运行的线程等于或多于 corePoolSize，则 Executor 始终首选将请求加入队列，而不添加新的线程。
如果无法将请求加入队列，则创建新的线程，除非创建此线程超出 maximumPoolSize，在这种情况下，任务将被拒绝。

排队有三种通用策略：

直接提交。工作队列的默认选项是 SynchronousQueue，它将任务直接提交给线程而不保持它们。在此，如果不存在可用于立即运行任务的线程，则试图把任务加入队列将失败，因此会构造一个新的线程。此策略可以避免在处理可能具有内部依赖性的请求集时出现锁。直接提交通常要求无界 maximumPoolSizes 以避免拒绝新提交的任务。当命令以超过队列所能处理的平均数连续到达时，此策略允许无界线程具有增长的可能性。
无界队列，即队列容量超出余下任务量。使用无界队列（例如，不具有预定义容量的 LinkedBlockingQueue）将导致在所有 corePoolSize 线程都忙时新任务在队列中等待。这样，创建的线程就不会超过 corePoolSize。（因此，maximumPoolSize 的值也就无效了。）当每个任务完全独立于其他任务，即任务执行互不影响时，适合于使用无界队列；例如，在 Web 页服务器中。这种排队可用于处理瞬态突发请求，当命令以超过队列所能处理的平均数连续到达时，此策略允许无界线程具有增长的可能性。
有界队列，即队列容量小于余下任务量。当使用有限的 maximumPoolSizes 时，有界队列（如 ArrayBlockingQueue或具有预定义容量的 LinkedBlockingQueue）有助于防止资源耗尽，但是可能较难调整和控制。队列大小和最大池大小可能需要相互折衷：使用大型队列和小型池可以最大限度地降低 CPU 使用率、操作系统资源和上下文切换开销，但是可能导致人工降低吞吐量。如果任务频繁阻塞（例如，如果它们是 I/O 边界），则系统可能为超过您许可的更多线程安排时间。使用小型队列通常要求较大的池大小，CPU 使用率较高，但是可能遇到不可接受的调度开销，这样也会降低吞吐量。

示例

package com.stone.threadpool;

import java.util.concurrent.*;

/**
 * Created by stone on 10/05/2017.
 */
public class Test {
    public static void main(String[] args) {
        ExecutorService pool = newThreadPool(2);
        for (int i = 0; i < 11; i++) {
            final int index = i;
            pool.execute(()-> {
                System.out.println(Thread.currentThread().getName() + " indexA=" + index);
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
// System.out.println(Thread.currentThread().getName() + " indexB=" + index);
            });
        }

    }

    public static ExecutorService newThreadPool(int nThreads) {

// return newFixedThreadPool(nThreads);

// return newSingleThreadPool();

// return newCachedThreadPool();

        return newLimitThreadPoll();

    }

    //生成一个固定线程数的 ThreadPoolExecutor
    public static ExecutorService newFixedThreadPool(int nThreads) {

// return new ThreadPoolExecutor(nThreads, nThreads,
        return new ThreadPoolExecutor(nThreads, nThreads * 3, //这时 maximumPoolSize没什么用

                0, TimeUnit.MILLISECONDS,

                new LinkedBlockingQueue<>()); //默认队列容量为Integer.MAX_VALUE

    }


    //生成一个只含一个线程的ThreadPoolExecutor
    public static ExecutorService newSingleThreadPool() {
        return new ThreadPoolExecutor(1, 1, //这里增大maximumPoolSize 也是没用的

                        0L, TimeUnit.MILLISECONDS,

                        new LinkedBlockingQueue<Runnable>());//默认队列容量为Integer.MAX_VALUE

    }

    //生成一个无界的并使用缓存的ThreadPoolExecutor
    public static ExecutorService newCachedThreadPool() {

        return new ThreadPoolExecutor(2, Integer.MAX_VALUE,

                60L, TimeUnit.SECONDS,

                new SynchronousQueue<Runnable>());//默认队列容量为Integer.MAX_VALUE

    }

    public static ExecutorService newLimitThreadPoll() {
        return new ThreadPoolExecutor(2, 5,

                0l, TimeUnit.SECONDS,

// new ArrayBlockingQueue<Runnable>(5));
                new LinkedBlockingQueue<>(5),
// new ThreadPoolExecutor.AbortPolicy()); //异常中止
// new ThreadPoolExecutor.CallerRunsPolicy()); //在当前线程直接执行
// new ThreadPoolExecutor.DiscardPolicy()); //空实现，跳过任务
                new ThreadPoolExecutor.DiscardOldestPolicy()); //移除队头，由pool执行
    }


}

Java ThreadPoolExecutor 线程池调度器