一蓑烟雨任平生

/**
 * Creates a new {@code ThreadPoolExecutor} with the given initial
 * parameters.
 *
 * @param corePoolSize the number of threads to keep in the pool, even
 *        if they are idle, unless {@code allowCoreThreadTimeOut} is set
 *        -- 当提交一个任务到线程池时，线程池会创建一个线程来执行任务，
 *        -- 即使其他空闲的基本线程能够执行新任务也会创建线程，
 *        -- 等到需要执行的任务数大于线程池基本大小时就不再创建。
 *        -- 调用prestartAllCoreThreads()后，线程池会提前创建并启动所有基本线程。
 * @param maximumPoolSize the maximum number of threads to allow in the
 *        pool
 *        -- 允许创建的最大线程数。如果队列满了，并且已创建的线程数小于最大线程数，
 *        -- 则线程池会再创建新的线程执行任务（无线队列会使该参数失效）。
 * @param keepAliveTime when the number of threads is greater than
 *        the core, this is the maximum time that excess idle threads
 *        will wait for new tasks before terminating.
 *        -- 线程池的工作线程空闲后，保持存活的时间。
 *        -- 如果任务很多，并且每个任务执行的时间比较短，可以调大时间，提高线程的利用率。
 * @param unit the time unit for the {@code keepAliveTime} argument
 * 		  -- 天（DAYS）、小时（HOURS）、分钟（MINUTES）、毫秒（MILLISECONDS）、
 *        -- 微秒（MICROSECONDS，千分之一毫秒）和纳秒（NANOSECONDS，千分之一微秒）
 * @param workQueue the queue to use for holding tasks before they are
 *        executed.  This queue will hold only the {@code Runnable}
 *        tasks submitted by the {@code execute} method.
 *        -- 用于保存等待执行的任务的阻塞队列
 *        -- ❑ ArrayBlockingQueue：基于数组结构的有界阻塞队列，排序规则：FIFO
 *        -- ❑ LinkedBlockingQueue：基于链表结构的阻塞队列，排序规则：FIFO，
                                    吞吐量通常要高于ArrayBlockingQueue。
                                    Executors.newFixedThreadPool()使用了这个队列。
 *        -- ❑ SynchronousQueue：一个不存储元素的阻塞队列（读写交换执行，否则会阻塞。）
                                  吞吐量通常要高于Linked-BlockingQueue，
                                  Executors.newCachedThreadPool使用了这个队列。
 *        -- ❑ PriorityBlockingQueue：一个具有优先级的无限阻塞队列。
 * @param threadFactory the factory to use when the executor
 *        creates a new thread
 *        -- 设置创建线程的工厂，可以通过线程工厂给每个创建出来的线程设置更有意义的名字。
 *        -- 使用开源框架guava提供的ThreadFactoryBuilder
             可以快速给线程池里的线程设置有意义的名字
 * @param handler the handler to use when execution is blocked
 *        because the thread bounds and queue capacities are reached
 *        -- 当队列和线程池都满了（饱和状态），那么必须采取一种策略处理提交的新任务。
 *        -- 这个策略默认情况下是AbortPolicy，表示无法处理新任务时抛出异常
 *        -- ❑ AbortPolicy：直接抛出异常。
 *        -- ❑ CallerRunsPolicy：只用调用者所在线程来运行任务。
 *        -- ❑ DiscardOldestPolicy：丢弃队列里最近的一个任务，并执行当前任务。
 *        -- ❑ DiscardPolicy：不处理，丢弃掉。
 *        -- 实现RejectedExecutionHandler接口自定义策略
 * @throws IllegalArgumentException if one of the following holds:<br>
 *         {@code corePoolSize < 0}<br>
 *         {@code keepAliveTime < 0}<br>
 *         {@code maximumPoolSize <= 0}<br>
 *         {@code maximumPoolSize < corePoolSize}
 * @throws NullPointerException if {@code workQueue}
 *         or {@code threadFactory} or {@code handler} is null
 */
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) {
    if (corePoolSize < 0 ||
        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;
}

* This class provides thread-local variables.  These variables differ from
* their normal counterparts in that each thread that accesses one (via its
* {@code get} or {@code set} method) has its own, independently initialized
* copy of the variable.  {@code ThreadLocal} instances are typically private
* static fields in classes that wish to associate state with a thread (e.g.,
* a user ID or Transaction ID).