线程池

线程池参数

线程池 Executor框架 参数7个 任务等待队列 拒绝策略
coreSize 核心线程数
maxSize 最大线程数
最大空闲时间 （超出核心线程数那部分线程的最大空闲时间）
空闲时间单位
创建线程的工厂 默认为DefaultThreadFactory
阻塞队列 根据业务需求配置
拒绝策略 实现接口RejectedExecutionHandler

内置线程池

newFixedThreadPool
定长的线程池，核心线程数和最大线程数相等，任务超出可用线程数会进入等待队列。
使用链表实现的阻塞队列，LinkedBlockingQueue，基于FIFO（先进先出）对任务进行排序
默认的拒绝策略 AbortPolicy 直接抛出异常

newCachedThreanPool
可缓存的线程池，核心线程数默认为1，最大线程数默认为Integer.MAX_VALUE
使用队列SynchronousQueue，不存储任务，每个插入操作必须等待另一个线程移除操作。
否则插入操作一直阻塞。
默认的拒绝策略 AbortPolicy 直接抛出异常

newSingleThreanExecutor
单一线程的线程池，核心线程数和最大线程数都是1，使用阻塞队列LinkedBlockingQueue
默认的拒绝策略 AbortPolicy 直接抛出异常

newScheduledThreanPool
创建一个定长线程池，支持定时及周期性任务执行。

newSingleScheduledThreanPool
创建一个单一线程的线程池，支持定时及周期性任务执行。

阻塞队列

线程池阻塞队列：
有界队列
ArrayBlockingQueue LinkedBlockingQueue
不存储元素的阻塞队列 SynchronousQueue
优先级的无界阻塞队列 PriorityBlockingQueue

拒绝策略：

接口RejectedExecutionHandler
默认的AbortPolicy
1、 AbortPolicy：直接抛出异常。
2、CallerRunsPolicy：使用调用者所在线程（提交任务的线程）来运行该任务。
3、DiscardOldestPolicy：丢弃队列里最老的一个任务，并执行当前任务。
4、DiscardPolicy：不处理，直接丢弃掉。
5、也可以根据应用场景需要来实现RejectedExecutionHandler接口自定义策略。如记录日志或持久化不能处理的任务。

线程池工作

1、创建线程池时默认创建一个线程数为空的线程池，可指定核心线程数(2)、最大线程数(10)、线程最长等待时间(6)、等待时间单位(seconds)、线程创建工厂(DefaultThreadFactory)、任务阻塞队列(new LinkedBlockingQueue< Runnable>(5))、任务拒绝策略(AbortPolicy)。

ThreadPoolExecutor executorService = new ThreadPoolExecutor(2,10,1L, TimeUnit.SECONDS,new LinkedBlockingQueue<Runnable>(5));

2、如果指定调用了prestartAllCoreThreads()或者prestartCoreThread()方法，则去创建线程，数量为核心线程数。

executorService.prestartAllCoreThreads(); 
// executorService.prestartCoreThread();

3 、任务提交时如果当前线程数小于核心线程数，创建新线程

if (workerCountOf(c) < corePoolSize) {
        	// 创建新线程加入到线程池
            if (addWorker(command, true))
                return;

4、当前线程数大于等于核心线程数,且线程池为运行状态则添加到阻塞队列

isRunning(c) && workQueue.offer(command)

5、 加入到阻塞队列失败，说明阻塞队列满了，继续创建线程直到达到最大线程数，线程数量达到最大线程数之后执行拒绝策略

else if (!addWorker(command, false))
            reject(command);

6、加入到阻塞队列成功之后，重新检查线程池状态，如果非运行状态，则删除任务并执行拒绝策略，

 int recheck = ctl.get();
            // 重新检查线程池状态 非运行状态 从阻塞队列删除 执行拒绝策略
            if (! isRunning(recheck) && remove(command))
                reject(command);

7、如果加入阻塞队列成功之后，线程数量为0，创建新线程。

else if (workerCountOf(recheck) == 0)
                addWorker(null, false);

总的代码流程如下：

public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();

        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);
                // 或者重新检查发现工作线程数量为0 创建新线程
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        // 工作线程数量大于核心线程数量 且加入阻塞队列失败（阻塞队列满了） 继续创建线程 创建线程失败（已达最大线程数量）执行拒绝策略
        else if (!addWorker(command, false))
            reject(command);
    }

private final HashSet< Worker > workers = new HashSet< Worker>(); 线程池容器
Worker内部类 实现了Runnable接口 继承了AbstractQueuedSynchronizer（AQS），持有一个线程属性，该类作为作为一个线程的载体。
线程创建成功之后会去启动。
线程池运行时从阻塞队列获取任务，该类的run方法中实现了该功能。
线程执行完当前任务的时候会从阻塞队列获取新的任务继续执行。
如果获取不到，阻塞队列空了。线程数超出核心线程数且获取超时，则会中断多余的线程。核心线程允许超时销毁的话，同样也会销毁。
核心线程不允许超时销毁的话，会一直等待在阻塞队列获取任务。直到任务提交到阻塞队列或者线程池关闭。
线程池关闭时，中断所有的线程。

// 创建新线程 并启动
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 {
        // 创建线程池 当前任务为首任务
            w = new Worker(firstTask);
            final Thread t = w.thread;
            if (t != null) {
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();
                try {
                    // Recheck while holding lock.
                    // Back out on ThreadFactory failure or if
                    // shut down before lock acquired.
                    int rs = runStateOf(ctl.get());

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

// Worker类的run方法
public void run() {
            runWorker(this);
        }
// 执行任务的逻辑
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 pool is stopping, ensure thread is interrupted;
                // if not, ensure thread is not interrupted.  This
                // requires a recheck in second case to deal with
                // shutdownNow race while clearing interrupt
                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);
        }
    }
// 获取任务方法
private Runnable getTask() {
        boolean timedOut = false; // Did the last poll() time out?

        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);

            // Check if queue empty only if necessary.
            if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
                decrementWorkerCount();
                return null;
            }

            int wc = workerCountOf(c);

            // Are workers subject to culling?
            boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
		// 当超出核心线程数 且获取任务等待超时之后返回null跳出
            if ((wc > maximumPoolSize || (timed && timedOut))
                && (wc > 1 || workQueue.isEmpty())) {
                if (compareAndDecrementWorkerCount(c))
                    return null;
                continue;
            }

            try {
            // 根据是否需要超时返回 调用不同的方法，
            //如果当前线程数小于核心线程数 且不允许核心线程数超时销毁 执行workQueue.take(); 阻塞在该方法中。
            //超出核心线程数的线程调用workQueue.poll(keepAliveTime,TimeUnit.NANOSECONDS) 
            // 等待超时之后未能获取到任务，设置超时标志timedOut = true;  下次会跳出返回null
                Runnable r = timed ?
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    workQueue.take();
                if (r != null)
                    return r;
                timedOut = true;
            } catch (InterruptedException retry) {
                timedOut = false;
            }
        }
    }

// 该方法在获取任务为null时会执行，用来销毁超出核心线程数的线程 
private void processWorkerExit(Worker w, boolean completedAbruptly) {
        if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
            decrementWorkerCount();
		// 直接从集合中删除该线程
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            completedTaskCount += w.completedTasks;
            workers.remove(w);
        } finally {
            mainLock.unlock();
        }
		// 尝试终止该线程，通过调用interruptIdleWorkers()中断线程 
        tryTerminate();

        int c = ctl.get();
        if (runStateLessThan(c, STOP)) {
            if (!completedAbruptly) {
                int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
                if (min == 0 && ! workQueue.isEmpty())
                    min = 1;
                if (workerCountOf(c) >= min)
                    return; // replacement not needed
            }
            addWorker(null, false);
        }
    }