Java线程池复用线程的秘密你知道吗

public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();        
        int c = ctl.get();
        //1.小于核心线程数时，创建线程
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        //2.达到核心线程数，不超过队列界限时，添加到队列
        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.队列已满，不超过最大线程数时，创建线程
        else if (!addWorker(command, false))
        //4.达到最大线程数时，执行拒绝策略
            reject(command);
    }

private boolean addWorker(Runnable firstTask, boolean core) {
        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {
        	//1.创建Worker，传入任务
            w = new Worker(firstTask);
            //2.取出执行任务的线程
            final Thread t = w.thread;
            if (t != null) {
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();
                try {                    
                    int c = ctl.get();
                    if (isRunning(c) ||
                        (runStateLessThan(c, STOP) && firstTask == null)) {
                        if (t.getState() != Thread.State.NEW)
                            throw new IllegalThreadStateException();
                        workers.add(w);
                        workerAdded = true;
                        int s = workers.size();
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                    }
                } finally {
                    mainLock.unlock();
                }
                if (workerAdded) {
                	//3.执行线程
                    t.start();
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }

private final class Worker    extends AbstractQueuedSynchronizer    implements Runnable

final Thread thread;
Runnable firstTask;

w = new Worker(firstTask);

Worker(Runnable firstTask) {
	this.firstTask = firstTask;    		
	this.thread = getThreadFactory().newThread(this);
}

w = new Worker(firstTask);
final Thread t = w.thread;
... ...
t.start();

public void run() { 
	runWorker(this);
}

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