ThreadPoolExecutor线程复用分析

看了篇介绍ThreadPoolExecutor文章，感觉很不错，但其中对于线程的复用没有具体指出，在此进行拓展

原文链接： https://segmentfault.com/a/1190000016629668

• 继承关系
  
• Executors工具创建所有线程池均是创建ThreadPoolExecutor对象，只是构造参数不同。不同的线程池创建时有不同的创建工厂、线程池大小及缓存队列等参数。所以线程池的实现均来自ThreadPoolExecutor类

1. 我们在使用时ThreadPoolExecutor的核心方法是submit方法，用于提交任务，由此进行分析，其直接用父类AbstractExecutorService方法没有重写

public Future<?> submit(Runnable task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<Void> ftask = newTaskFor(task, null);
        execute(ftask);
        return ftask;
    }

2. 但execute()方法为顶层接口Executor方法作为钩子，其进行了重写，该方法来根据各种条件来包装成工作线程Worker。（注意看注释）

public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        int c = ctl.get();
        //目前工作线程数<核心数，包装成Worker，后面会介绍
        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)
            //如果放入队列后发现没有工作线程，则包装一个没有任务的Worker，其作用其实就是去轮训执行队列里面的任务
                addWorker(null, false);
        }
        //队列满了，加入非核心线程池，如果失败，执行拒绝策略
        else if (!addWorker(command, false))
            reject(command);
    }

3. 重点就是包装成Worker这个工作线程的实现了，可以不用仔细看源码，这个方法最重要的功能就是生成了Worker对象，并且启动了该对象的线程运行。该对象在new的时候由工厂创建了一个新线程，这里的t.start()下来即会执行本方法的参数firstTask。

private boolean addWorker(Runnable firstTask, boolean core) {
        // 前面这里有一些自旋校验代码省略了

        Worker w = null;
        try {
            //在这里new了一个Worker类，下面介绍
            w = new Worker(firstTask);
            final Thread t = w.thread;
            if (t != null) {
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();
                try {
              			//这里省略一堆校验代码
              			//把生成的工作线程加入线程集合
                        workers.add(w);
                        int s = workers.size();
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                        workerAdded = true;
                    }
                } finally {
                    mainLock.unlock();
                }
                if (workerAdded) {
                	//Worker线程启动，这个启动比较重要，后面说明
                    t.start();
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }

4. Worker这个类就是实现线程复用的根本，其实现了AQS用来进行线程间的同步，并且实现Runnable重写run方法。在构造函数生成Thread时传入自己，使线程执行start方法时最终调用是自己的run方法下的runWorker方法；
   上面一步生成Worker后，启动worker.thread.start方法，即开始执行runWorker方法。

private final class Worker
        extends AbstractQueuedSynchronizer
        implements Runnable
    {
    	//构造函数，生成Thread时把自身传入线程内部，因为自身实现了Runnable接口
        Worker(Runnable firstTask) {
            setState(-1); // inhibit interrupts until runWorker
            this.firstTask = firstTask;
            this.thread = getThreadFactory().newThread(this);
        }
		//重写Runnable接口的run方法
        public void run() {
            runWorker(this);
        }

5. 首先要想明白，在线程调用start方法后，是由JVM自己去执行Runnable的run方法的，也就是下面runWorker方法已经是某个线程内的执行方法了。该方法就是执行Worker的任务，如果任务执行完毕或者没有任务（第2步中会有建立空任务的Worker），则去队列中拿任务来执行即getTask()方法。

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();
                //省略校验代码
                try {
                    beforeExecute(wt, task);
                    Throwable thrown = null;
                    try {
                        task.run();
                    } catch (RuntimeException x) {
                    	//省略异常处理代码
                    }
                } finally {
            ...//省略
    }

6. getTask()方法不多解释，就是自旋去拿队列中的任务

小结

• 核心线程和非核心线程本质上没有区别，都是创建了一个Worker，只是非核心线程执行完后立即释放，核心线程会一直轮循队列任务执行
• Worker中的线程会执行自身的runWorker方法，该方法会一直取队列中的任务去执行。线程池节省的是Thread创建和销毁的时间，Worker中的线程由工厂创建，节省的时间就是不用一直创建Thread，而是在多个核心Thread中一直去取队列的任务来处理