Java并发编程-线程池

1.线程池概述
    什么是线程池？
    为什么使用线程池即线程池的优势？
    （1）降低资源消耗，通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
    （2）提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。
    （3）提高线程的可管理性，线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控，但是要做到合理利用线程池，必须对其原理了如指掌。

2.创建一个线程池并提交线程任务
线程池源码解析
参数认识
    （1）corePoolSize:线程池的基本大小，当提交一个任务到线程池时，线程池会创建一个线程来执行任务，即使其他空闲的基本线程能够执行新任务也会创建线程，等到需要执行的任务数大于线程池的基本大小时就不再创建。如果调用了线程池的prestartAllCoreThreads方法，线程池会提前创建并启动所有基本线程。

    （2）runnableTaskQueue:任务队列，用于保存等待执行的任务的阻塞队列。可以选择以下几个阻塞队列。ArrayBlockingQueue:是一个基于数组结构的有界阻塞队列。此队列按FIFO原则对元素进行排序。静态工厂方法Executors.newFixedThreadPool()使用了这个队列。LinkedBlockingQueue:是一个基于链表结构的阻塞队列，此队列按FIFO排序元素，吞吐量通常要高于ArrayBlockingQueue。静态工厂方法Executors.newCachedThreadPool使用了这个队列。 SynchronousQueue:一个不存储元素的阻塞队列。每个插入操作必须等到另一个线程调用移除操作，否则插入操作就一直处于阻塞状态，吞吐量通常要高于LinkedBlockingQueue。PriorityBlockingQueue:一个具有优先级的无界阻塞队列。

    （3）maximumPoolSize:线程池的最大大小，线程池允许创建的最大线程数。如果队列满了，并且已创建的线程数少于最大线程数，则线程池泽会再创建新的线程执行任务，但是如果使用了无界的任务队列，这个参数就没有什么效果。

    （4）ThreadFactory:用于设置创建线程的工厂，可以通过线程工厂给每个创建出来的线程设置更有意义的名字，debug和定位问题时非常有帮助。

    （5）RejectedExecutionHandler:当队列和线程池都满了，说明线程池处于饱和状态，那么必须采取一种策略处理提交的新任务。这个策略默认情况下是AbortPolicy，表示无法处理新任务时抛出异常。
    CallerRunsPolicy:只用调用者所在线程来运行任务。
    DiscarOldestPolicy:丢弃队列里最近的一个任务，并执行当前任务。
    DiscardPolicy:不处理，丢弃掉。
    也可以根据应用场景需要来实现RejectedExecutionHandler接口自定义策略。如记录日志或持久化不能处理的任务。

    （6）keepAliveTime:线程活动保持时间，线程池的工作线程空闲后，保持存活的时间。所以如果任务很多，并且每个任务执行的时间比较短，可以调大这个时间，提高效率。

    （7）TimeUnit:线程活动保持时间的单位，可选的单位有天，小时，分钟，毫秒，微妙，纳秒。

    （8）类中其他属性
    // 表示运行状态和线程数量
    private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
    private static final int COUNT_BITS = Integer.SIZE - 3;
    private static final int CAPACITY   = (1 << COUNT_BITS) - 1;

    // runState is stored in the high-order bits
    // 运行状态存储在高位
    // 11100000000000000000000000000000
    private static final int RUNNING    = -1 << COUNT_BITS;
    // 00000000000000000000000000000000
    private static final int SHUTDOWN   =  0 << COUNT_BITS;
    // 100000000000000000000000000000
    private static final int STOP       =  1 << COUNT_BITS;
    // 1000000000000000000000000000000
    private static final int TIDYING    =  2 << COUNT_BITS;
    // 1100000000000000000000000000000
    private static final int TERMINATED =  3 << COUNT_BITS;
3.构造方法
    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.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }
    其他变形的构造函数，只是给指定的参数赋上默认值。
4.提交任务
    /**
     *
     * 在将来某个时间执行给定的任务。这个任务可能在一个新的线程或者一个存在的线
     * 程中执行。
     * 如果这个任务不能提交执行，可能因为执行器已经关闭或这因为已将到达容量上限，这个任务
     * 会被拒绝执行处理器处理。
     *
     */
    public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        /*
         *
         * 如果有少于核心线程数的线程运行，尝试以给定的命令作为第一个任务开始一个新
         * 线程。addWorker的调用自动检查运行状态和工作者线程数量，所以通过返回false
         * 防止当它在不应该添加线程时添加线程的虚假报警。
         *
         *
         * 如果一个任务成功地排队，然后我们还需要两次检查我们是否应该添加一个线程(因为
         * 自从最后一次检查存在的线程已经退出)或者进入该方法线程池关闭。所以我们重新检查
         * 状态，并且如果必要，回滚入队，如果线程池停止，没有线程，开启一个新的线程。
         *
         * 如果我们无法排队任务，然后我们尝试添加一个新的线程。如果失败，我们知道是线程池关闭
         * 或者任务队列饱和，所以拒绝这个任务。
         */
        int c = ctl.get();
        // 如果工作者线程数量少于核心线程数，新建一个线程
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        // 如果线程池还在运行状态并且将任务入队成功
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            // 如果线程池不在运行状态并且任务删除成功，执行拒绝策略
            if (! isRunning(recheck) && remove(command))
                reject(command);
            // 线程池停止，重新开启一个新的线程
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        // 尝试添加一个新的线程
        else if (!addWorker(command, false))
            reject(command);
    }
   5. addWorker
    1.原子性地增加workCount
    2.将用户给定的任务封装成为一个worker，并将此worker添加进workers集合中。
    3.启动worker对应的线程，并启动该线程，运行worker的run方法。
    4.回滚worker的创建动作，即将worker从workers集合中删除，并原子性地减少workerCount。
     /**
     *
     * 检查关于当前线程池状态和给定界限(核心线程或最大线程)是否可以加入一个新的工作者。
     * 如果可以，工作者数量随之调整，如果可能一个新的工作者创建并开启，执行第一个任务
     * 作为任务。如果线程池停止或者可以关闭，这个方法返回false。如果线程工厂当要求创建
     * 线程时失败，它也会返回false。如果这个线程创建失败，因为线程工厂创建失败或者线程
     * 工厂返回空，或者因为异常(典型的如Thread.start的OutOfMemoryError)，我们回滚。
     *
     * 新线程应该第一个运行的任务(如果没有为空)。以第一个初始化任务创建工作者(
     * 在execute方法中)来忽视排队，当线程数少于核心线程数时(这种情况下我们总是开始一个)，
     * 或者当队列为空(这种情况我们必须忽略队列)。初始化地空闲线程通常通过prestartCoreThread
     * 创建或者来替换其他死亡工作者。
     *
     * 如果使用核心线程数作为边界为真，否则为最大线程数。(这里使用布尔指示符而不是一个值，以确保在
     * 检查其他池状态之后读取新值)。
     * 
     */
    private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);

            // Check if queue empty only if necessary.
            // 必要时检查队列是否为空
            // 线程池状态不为运行状态或当线程池状态不为关闭时，
            // 或第一个任务不为空时，或者任务队列为空时
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))
                return false;

            for (;;) {
                // 工作者数量
                int wc = workerCountOf(c);
                // 无法增加工作者
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
                // 增加工作者成功
                if (compareAndIncrementWorkerCount(c))
                    break retry;
                c = ctl.get();  // Re-read ctl
                if (runStateOf(c) != rs)
                    continue retry;
                // else CAS failed due to workerCount change; retry inner loop
            }
        }

        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {
            final ReentrantLock mainLock = this.mainLock;
            w = new Worker(firstTask);
            final Thread t = w.thread;
            if (t != null) {
                mainLock.lock();
                try {
                    // Recheck while holding lock.
                    // Back out on ThreadFactory failure or if
                    // shut down before lock acquired.
                    // 持有锁时重新检查
                    // 当线程工厂失败或者在获取琐时队徽
                    int c = ctl.get();
                    int rs = runStateOf(c);

                    if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) {
                        if (t.isAlive()) // precheck that t is startable
                            throw new IllegalThreadStateException();
                        workers.add(w);
                        int s = workers.size();
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                        workerAdded = true;
                    }
                } finally {
                    mainLock.unlock();
                }
                if (workerAdded) {
                    t.start();
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }

6.执行任务
    runWorker函数中会实际执行给定任务(即调用用户重写的run方法)，并且当给定任务完成后，会继续从阻塞队列中取任务，直到阻塞队列为空。在执行给定任务时，会调用钩子函数，利用钩子函数可以完成用户自定义的一些逻辑。在runWorker中会调用到getTask函数和processWorkerExit钩子函数。
    processWorkerExit函数是在worker退出时调用到的钩子函数，而引起worker退出的主要因素如下:
    1.阻塞队列已经为空，即没有任务可以运行了。
    2.调用了shutDown或shutDownNow函数。
    此函数会根据是否中断了空闲线程来确定是否减少workerCount的值，并且将worker从workers集合中移除并且会尝终止线程池。
     /**
     *
     * 主要的工作者线程运行循环。在处理一些问题的同时，重复地从队列中获取任务执
     * 行它们。
     *
     * 我们可能从一个初始化任务开始，这种情况我们不需要获取第一个任务。否则，随着线程
     * 池的运行，我们从getTask获取任务。如果它返回为空，工作者会因为线程池状态的改变
     * 或者配置参数的改变而退出。其他外部代码抛出异常的退出结果，在这种情况下completedAbruptly
     * 会为真，它通常导致processWorkerExit执行来替换这个线程。
     *
     * 在运行任何任务之前，应该获取锁来阻止当任务执行时的其他线程池的中断，除非线程
     * 池停止运行，否则clearInterruptsForTaskRun会被调用来确保这个线程没有它的
     * 中断集合。
     *
     * 每个任务先于beforeExecute运行，它可能抛出异常，在这种情况下线程死亡(因为completedAbruptly
     * 为真跳出循环)而不去处理任务。
     *
     * 假如beforeExecute正常执行完毕，我们运行这个任务，聚集了所有它抛出的异常发送到
     * afterExecute方法。我们分别处理运行时异常，错误(两者都保证了我们的陷阱)和其他
     * 异常。因为我们不能在run方法中重新抛出异常，我们在错误的范围内包装他们(线程未捕获
     * 异常)。任何抛出的异常也会造成线程死亡。
     *
     * 在run方法执行完毕后，我们调用afterExecute，它也可能抛出一个异常，它也会造成
     * 线程死亡。根据JLS规范，这个异常即使是任务.run方法抛出的也会生效。
     *
     * 这种异常机制的网络效应是afterExecute和线程未捕获异常处理器拥有我们可以提供
     * 的有关于用户遇到的所有问题的准确信息。
     *
     */
    final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
            while (task != null || (task = getTask()) != null) {
                w.lock();
                // 如果线程池停止了，保证线程被中断；
                // 如果没有，确保线程没有中断。
                // 这个要求第二次重新检查来解决当清理中断时的关闭竞争
                if ((runStateAtLeast(ctl.get(), STOP) ||
                     (Thread.interrupted() &&
                      runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())
                    wt.interrupt();
                try {
                    beforeExecute(wt, task);
                    Throwable thrown = null;
                    try {
                        task.run();
                    } catch (RuntimeException x) {
                        thrown = x; throw x;
                    } catch (Error x) {
                        thrown = x; throw x;
                    } catch (Throwable x) {
                        thrown = x; throw new Error(x);
                    } finally {
                        afterExecute(task, thrown);
                    }
                } finally {
                    task = null;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            processWorkerExit(w, completedAbruptly);
        }
    }

7.关闭线程池
    shutDown
     /**
     *
     * 启动一个有序的关闭，其中先前提交的任务会被执行，但不会接受新的任务。如果已经
     * 关闭，调用没有附加影响。
     *
     */
    public void shutdown() {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            checkShutdownAccess();
            advanceRunState(SHUTDOWN);
            interruptIdleWorkers();
            onShutdown(); // hook for ScheduledThreadPoolExecutor
        } finally {
            mainLock.unlock();
        }
        tryTerminate();
    }
    shutDownNow
     /**
     *
     * 尝试停止所有的活跃地正在执行的任务，停止等待任务的处理，返回一个等待执行的任务
     * 列表。当从这个方法返回时这些任务会从任务队列移除。
     *
     * 除了尽力处理主动执行任务以外，没有尽力保证。这个实现通过interrupt方法取消任务，所以
     * 任何对interrupts的失败相应可能绝不会终止。
     *
     */
    public List<Runnable> shutdownNow() {
        List<Runnable> tasks;
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            checkShutdownAccess();
            advanceRunState(STOP);
            interruptWorkers();
            tasks = drainQueue();
        } finally {
            mainLock.unlock();
        }
        tryTerminate();
        return tasks;
    }