线程池ThreadPoolExecutor源码分析（二）

线程池中的工作线程是如何实现线程复用的？一个线程一般在执行完任务后就结束了，怎么再让他执行下一个任务呢？　

当我们往线程池添加任务的时候使用ThreadPollExcutor对象的execute(Runnable command)方法来完成的。那我们就来看一下这个逻辑部分的代码：

   public void execute(Runnable command) {
        int c = ctl.get();
        if (workerCountOf(c) < corePoolSize) {
            //1、当前工作线程小于corePoolSize，新建worker线程并返回
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
       
        //2、如果当前工作线程大于等于corePoolSize，添加至任务到队列。并进行二次确认（确认队列是否关闭，进行回滚）
        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);
        }
       
        //3、添加队列失败后，则尝试新建非core线程，失败则拒绝任务。
        else if (!addWorker(command, false))
            reject(command);
    }

可以看出：ThreadPoolExecutor.execute()的功能就是：

• 将任务添加至阻塞队列workQueue：workQueue.offer(command)
• 根据corePoolSize和maxPool，选择是否创建Worker：addWorker()

其中我们可以看到核心逻辑是执行addWorker，线程复用的实现应该在worker中，打开addWorker()方法观察：

private boolean addWorker(Runnable firstTask, boolean core) {
  w = new Worker(firstTask);
  final Thread t = w.thread;
  ...//代码
  t.start();
  ...//代码
}

上面代码逻辑中新建Worker对象，其实可以猜测到就是新建线程并启动。到Worker类看一下，是一个内部私有类，实现了Runnable接口。在run方面里面只有一句runWorker：

private final class Worker    extends AbstractQueuedSynchronizer    implements Runnable{.....
    
     public void run() {
            runWorker(this);
    }

                                                                                }

参考了网上一个简化的runWorker(this)方法的写法：

    final void runWorker(Worker w) {
    Runnable task = w.firstTask;
    w.firstTask = null;
    while (task != null || (task = getTask()) != null) {
            try {
                task.run();
            } finally {
                task = null;
            }
        }
}

很显然这个runWorker很不得了，里面一个大大的while循环，当我们的task不为空的时候它就永远在循环，并且会源源不断的从getTask()获取新的任务，继续看getTask()方法:

//很显然这个方法是从队列中获取任务workQueue
private Runnable getTask() {
       ...//代码
       // Are workers subject to culling?
        boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
        if ((wc > maximumPoolSize || (timed && timedOut))
            && (wc > 1 || workQueue.isEmpty())) {
            if (compareAndDecrementWorkerCount(c))
                return null;
            continue;
        }
        
        try {
            Runnable r = timed ?
                workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                workQueue.take();
            if (r != null)
                return r;
            timedOut = true;
        } catch (InterruptedException retry) {
            timedOut = false;
        }
    }
}

分析到这里线程复用的流程就算完了，最核心的一点是：新建一个Worker内部类就会建一个线程，并且会把这个内部类本身传进去当作任务去执行，这个内部类的run方法里实现了一个while循环，当任务队列没有任务时结束这个循环，则这个线程就结束。

总结：线程重用的核心是，我们知道，Thread.start()只能调用一次，一旦这个调用结束，则该线程就到了stop状态，不能再次调用start。则要达到复用的目的，则必须从Runnable接口的run()方法上入手，可以这样设计这个Runnable.run()方法（就叫外面的run()方法）：
它本质上是个无限循环，跑的过程中不断检查我们是否有新加入的子Runnable对象（就叫内部的runnable:run()吧，它就是用来实现我们自己的任务），有就调一下我们的run()，其实就一个大run()把其它小run()#1,run()#2,...给串联起来了，不停地处理我们提交的Runnable任务，基本原理就这么简单。


期间参考众多资料，具体有哪些自己也理不清了。如果冒犯，敬请联系~