5.0's ThreadPoolExecutor

Question

It appears that this implementation replaces the thread that ran a task with a brand-new thread. If i understand this correctly, why not keep the thread around in waiting state until another task comes up, and then wake it up when the new task comes in? I read something that it might be more robust to replace a thread after an exception, but in this case, even that is not being considered, from what i see. The replacement is done regardless of whether there have been exceptions.
The only thing i can think of why that is done is to have a fresh start every time, for robustness. In that case, how risky is it to have a thread pool that keeps the threads in waiting state, and then wakes them up as tasks arrive, and then puts into waiting state again, and so on?
Thanks.

Answer 1

Looking at the source code. I may be mistaken, but from the code below, i conclude it replaces threads with new ones, instead of keeping threads in wait state.
My understanding is as follows, starting at first execute call:
TPE.addIfUnderCorePoolSize->TPE.addThread->Thread.start->Thread.run->
while(<hasTask>)
Runnable.run->TPE.workerDone
If pool size becomes 0 in TPE.workerDone, then TPE replaces the running thread with a new one, otherwise the running thread completes its execution, and we have one thread less. I.e., when there are no tasks to run, the TPE will have no threads in the pool. This is my understanding, but if it's not correct (i didn't have a lot of time to look thru the code), please correct.
A thread pool that i made for our application (we can't use 1.5, and external libraries aren't very welcome; not my call), keeps the threads in waiting state when there are no tasks to run. That's why i wonder...
Thanks.
    private Thread addThread(Runnable firstTask) {
        Worker w = new Worker(firstTask);
        Thread t = threadFactory.newThread(w);
        if (t != null) {
            w.thread = t;
            workers.add(w);
            int nt = ++poolSize;
            if (nt > largestPoolSize)
                largestPoolSize = nt;
        return t;
    private boolean addIfUnderCorePoolSize(Runnable firstTask) {
        Thread t = null;
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            if (poolSize < corePoolSize)
                t = addThread(firstTask);
        } finally {
            mainLock.unlock();
        if (t == null)
            return false;
        t.start();
        return true;
        public void run() {
            try {
                Runnable task = firstTask;
                firstTask = null;
                while (task != null || (task = getTask()) != null) {
                    runTask(task);
                    task = null; // unnecessary but can help GC
            } catch(InterruptedException ie) {
                // fall through
            } finally {
                workerDone(this);
    void workerDone(Worker w) {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            completedTaskCount += w.completedTasks;
            workers.remove(w);
            if (--poolSize > 0)
                return;
            // Else, this is the last thread. Deal with potential shutdown.
            int state = runState;
            assert state != TERMINATED;
            if (state != STOP) {
                // If there are queued tasks but no threads, create
                // replacement thread. We must create it initially
                // idle to avoid orphaned tasks in case addThread
                // fails.  This also handles case of delayed tasks
                // that will sometime later become runnable.
                if (!workQueue.isEmpty()) {
                    Thread t = addThread(null);
                    if (t != null)
                        t.start();
                    return;
                // Otherwise, we can exit without replacement
                if (state == RUNNING)
                    return;
            // Either state is STOP, or state is SHUTDOWN and there is
            // no work to do. So we can terminate.
            termination.signalAll();
            runState = TERMINATED;
            // fall through to call terminate() outside of lock.
        } finally {
            mainLock.unlock();
        assert runState == TERMINATED;
        terminated();
    }