ThreadPoolExecutor线程池-水太深你把握不住

本文基于jdk1.8
线程池是池化技术的一种实现，是为了避免频繁创建线程而出现的。

一. 构造方式

最全的构造方法如下:

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        ...
    }

• corePoolSize:
  核心线程数，添加任务到堵塞队列前，最大能创建的线程数。
• maximumPoolSize:
  最大线程数, 线程池最大能创建的线程数。
• keepAliveTime :
  任务放弃等待多长时间。
• unit：
  空闲时间单位。
• workQueue:
  堵塞队列,超出核心线程数，任务加入堵塞队列。
• threadFactory:
  线程工厂，用于创建线程，默认的工厂Executors.defaultThreadFactory()。
• RejectedExecutionHandler:
  拒绝策略,超出线程池最大能执行的任务数量，执行的拒绝策略。默认策略AbortPolicy。

二. 工作原理

ThreadPoolExecutor 执行任务有submit和execute，区别在于submit方法有返回值.以下以execute进行分析

 public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException(); 
        int c = ctl.get();
        // 当前的线程数<核心线程数
        if (workerCountOf(c) < corePoolSize) {
        	// 添加一个线程,添加成功返回
        	// 添加失败重新获取当前状态，失败原因可能是:
        	// 1.线程池罢工 
        	// 2.其他线程抢了线程名额，工作线程超出核心线程数
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        // isRunning判断是不是线程池罢工了
        // 线程池正常则向堵塞队列workQueue加入任务
        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);
    }

workerCountOf方法，用于获取当前工作线程数,这里到涉及位掩码可以参考另一篇文章。
根据源码，梳理工作流程图如下:

三. 拒绝策略

内置了4种拒绝策略，分别如下:

1. AbortPolicy,该策略为默认策略，处理方式简单粗暴直接抛出异常。
2. CallerRunsPolicy，处理方式为调用当前主线程执行该任务。
3. DiscardPolicy，该策略是直接抛弃该任务，什么都不处理(偷偷当做没看见→_→)。
4. DiscardOldestPolicy，该策略是个狠人，处理方式是丢弃最老的任务，把直接加入进去。

四. 添加工作线程addWorker

 private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        for (;;) {
            int c = ctl.get();
            // 获取线程池状态
            int rs = runStateOf(c);

            // 线程池停止，返回false
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))
                return false;
			
            for (;;) {
            	// 获取当前线程数 
                int wc = workerCountOf(c);
                // 如果超出最大线程数或者核心线程数，返回false
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
                 // 添加线程池工作数成功，回到 retry处往下进行实际线程的创建逻辑 
                if (compareAndIncrementWorkerCount(c))
                    break retry;
                // 添加线程数失败，重新获取当前状态    
                c = ctl.get(); 
                // 当前状态和之前状态不一致，可能有意外也退出循环
                if (runStateOf(c) != rs)
                    continue retry;
                // 其他状态是CAS添加线程数失败，继续循环尝试
            }
        }

        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {
           // 创建一个线程包裹对象Work,Worker会创建调用线程工厂创建一个线程
            w = new Worker(firstTask);
            // 获取新建的线程
            final Thread t = w.thread;
            if (t != null) {
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();
                try {
                    // 重新获取线程池状态
                    int rs = runStateOf(ctl.get());
					// 线程池一切正常|| 线程池shutdown，线程优先任务不存在
                    if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) {
                        // 当前线程逻辑上还未运行，但实际已运行，抛出状态异常
                        if (t.isAlive())
                            throw new IllegalThreadStateException();
                        // workers包含所有线程池所有的work对象  
                        workers.add(w);
                        int s = workers.size();
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                        // 标识work添加成功     
                        workerAdded = true;
                    }
                } finally {
                    mainLock.unlock();
                }
                // worker添加成功，启动线程
                if (workerAdded) {
                    t.start();
                   	// 标识线程运行成功
                    workerStarted = true;
                }
            }
        } finally {
        	// 线程启动失败，执行回滚操作
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }

五. 运行任务runWorker

工作线程实现Runnable，线程运行时会调用run方法，而run实际调用了runWorker方法。

final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock();
        boolean completedAbruptly = true;
        try {
        	// 获取任务或者从队列中获取队列
            while (task != null || (task = getTask()) != null) {
                w.lock();
                // 如果池正在停止，确保线程被中断；如果没有，请确保线程不被中断。
                // 这需要在第二种情况下重新检查以在清除中断的同时处理 shutdownNow 竞争
                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();
                    } 
                    ... // 异常处理
                    } finally {
                    	// 后置操作，默认空方法
                        afterExecute(task, thrown);
                    }
                } finally {
                    task = null;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            // 对于关闭空闲线程进行关闭操作
            processWorkerExit(w, completedAbruptly);
        }
    }

六.获取任务

获取队列任务简单来说: 不断循环，从队列取任务，队列为空则堵塞住队列，直至有值。如果工作线程超过核心线程数，且任务队列为空，返回null，便于关闭空闲线程。

    private Runnable getTask() {
        boolean timedOut = false;
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);
			// 省略校验逻辑
          	...
          	// 获取当前线程数
          	int wc = workerCountOf(c);
          	boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
          	...
            try {
                Runnable r = timed ?
                	// poll超时获取失败，立即返回null
                	// take获取失败堵塞等待释放cpu
                	// 故这里是为了空队列，进行空循环的优化
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    workQueue.take();
                if (r != null)
                    return r;
                timedOut = true;
            } catch (InterruptedException retry) {
                timedOut = false;
            }
        }
    }