线程池如何做到线程复用的

BlockingQueueworkQueue = new ArrayBlockingQueue(10);
for(;;){
    Runnable r =  workQueue.take();
    r.run();
}

public void execute(Runnable command) {
    int c = ctl.get();
    if (workerCountOf(c) < corePoolSize) {
        if (addWorker(command, true))
            return;
    }
    if (isRunning(c) && workQueue.offer(command)) {
    }
    else if (!addWorker(command, false))
        reject(command);
}

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

private final class Worker extends AbstractQueuedSynchronizer    
    implements Runnable {
    Runnable firstTask;
    Worker(Runnable firstTask) {
        setState(-1); // inhibit interrupts until runWorker
        this.firstTask = firstTask;
        this.thread = getThreadFactory().newThread(this);
    }
    public void run() {
        runWorker(this);
    }}

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

private Runnable getTask() {
     Runnable r = timed ?
        workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
        workQueue.take();
        return r;
 }