从源码看线程池执行任务的流程及原理

1. 线程池的必要性与核心参数

频繁创建、销毁线程的开销过大，所以创建线程频率高的场景一般都选择使用线程池，例如tomcat与客户端通信时处理发来的请求。创建线程池的参数如下

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

• corePoolSize：池中核心线程数量，线程数量不大于corePoolSize时线程不会因为空闲时间超过阈值而被销毁。
• maximumPoolSize：最大线程数，当线程数量大于corePoolSize而小于maximumPoolSize时，如果一个线程空闲时间超过阈值，则会被回收。
• keepAliveTime：非核心线程空闲的最大时间，超过这个值就会被回收。
• unit：keepAliveTime参数的时间单位。
• workQueue：用来暂存任务的队列。
• threadFactory：提交到线程池的是任务需要包装成线程来执行，threadFactory就是用来生产线程的。
• handler：当线程池由于各种原因不接受一个任务时，使用这个对象的拒绝方法拒绝，不同的实现类的拒绝策略不同，直接抛异常/重试/无视

根据不同的参数搭配，创建的线程池适应不同的场景，Executors类可以生成几种典型的线程池：

• 固定线程数的线程池：corePoolSize、maximumPoolSize设置成一样，并使用无界的阻塞队列。这样线程池数量从0增加到corePoolSize后就一直保持这个数量，再有任务来时直接加入阻塞队列，反正阻塞队列是无界限的。这种线程池适合并发量较大且波动不大的场景，但是要注意队列过大占用资源的问题。
• 单线程线程池：固定线程数线程池的特殊场景，corePoolSize、maximumPoolSize都设为1即可。适合并发量稳定保持在低水平的场景，也要注意阻塞队列过大的问题。
• 直接提交线程池：corePoolSize设为0，maximumPoolSize设为最大值，阻塞队列是一个直接提交的队列，对于新来的任务每次都建立线程处理。适合并发量很难确定的场景。

2. 执行任务的流程

• 接收到任务后的主流程

public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        //获取线程池状态及当前线程数记录，高3位记录状态，低29位记录线程数
        int c = ctl.get();   
        //如果线程数小于核心线程阈值
        if (workerCountOf(c) < corePoolSize) {
            //直接包装成Worker运行（true表示将任务以核心线程身份包装）
            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);
        }
        //如果前面加入工作队列失败，则以非核心线程身份包装任务（false标志）
        else if (!addWorker(command, false))
            reject(command);  //如果上一步也失败，则拒绝这个任务
    }

总结：（1）来了新任务，先查看核心线程数是否已经达到，未达到则直接以核心线程的方式新建线程执行任务；（2）如果线程数已经达到核心阈值则将任务加入阻塞队列；（3）如果加入队列失败则以非核心的方式建立线程执行任务；（4）还是失败则拒绝这个任务

• 新建线程执行任务：addWorker(Runnable firstTask, boolean core)的操作

private boolean addWorker(Runnable firstTask, boolean core) {
        /**
        此处省略一段代码，大致工作是检查当前线程数量是否小于阈值（否就返回false），
        CAS的检查线程池状态和CAS的将线程数+1。
        */
        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {
 //根据任务包装Worker，Worker对象有一个线程对象也在此时根据Worker对象生成，Worker实现了Runnable接口
            w = new Worker(firstTask);   
            //获取Worker里生成的线程对象
            final Thread t = w.thread;   
            if (t != null) {
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();
                try {
                    //获取线程状态
                    int rs = runStateOf(ctl.get());
                    //检查线程池状态的合法性
                    if (rs < SHUTDOWN ||(rs == SHUTDOWN && firstTask == null)) {
                        if (t.isAlive()) // 如果此刻线程就已经活跃，那么就是出错了
                            throw new IllegalThreadStateException();
                        workers.add(w);      //将生成的Worker对象放到Set集合
                        int s = workers.size();
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                        workerAdded = true;  //记录Worker已经成功添加到集合
                    }
                } finally {
                    mainLock.unlock();
                }
                if (workerAdded) {
                    t.start();     //如果Worker对象已经成功添加，则启动这个对象的线程
                    workerStarted = true;  //记录任务已经开始执行
                }
            }
        } finally {
            if (! workerStarted)
                addWorkerFailed(w);   //如果最终发现任务没有标志为开始，则调用响应处理方法
        }
        return workerStarted;
    }

这里要注意Worker本身实现了Ruunable接口有一个run方法，Worker对象持有提交来的task和一个线程对象，这个线程对象根据Worker对象生成所以运行的是Worker的run方法，而Worker的run方法里又是调用了task的run方法。其实就是一个代理模式：Worker对象代理了提交的task。

所以现在知道了t.start()后会运行Worker的run方法，下面看Worker的run方法：

 public void run() {
            runWorker(this);  //调用另一个runWorker方法，并将自己传入
        }

• 真正运行任务的方法：runWorker(Worker w)

final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;  //首先拿到提交的那个task
        w.firstTask = null;
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
            //核心操作就是循环的getTask()，从阻塞队列里拿task来执行
            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();    //执行真实角色的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);
        }
    }

可以看到，使用Worker的run方法作为线程的运行方法代理task的run方法，主要操作是在运行完task的run方法后再getTask()去队列里获取新任务继续执行。