Thread pool library

Question

Hello all,
Does anybody know an open-source library that provides a thread pool with the following behavior?
When a task is submitted...
if (there are idle threads in the pool) {
    use an idle thread to execute the task.
} else {
    if (currentThreadCount < maximumPoolSize) {
        create new thread to execute the task.
    } else {
        put the task in the queue.
        (tasks in the queue will be processed when threads are available).
}If a thread remains idle for X time, it dies.
Thank you

Answer 1

I ran your code and it ran it just fine, I prefixed your println to print out the currentTimeMillis to show it ran right after each other.
System.out.println(System.currentTimeMillis() +  "{code}
Here is the result:
1244482518471 Starting main.
1244482518483 Running a task
Here is code fragments from ThreadPoolExecutor I generated my sudo code from.
{code}
     * Executes the given task sometime in the future.  The task
     * may execute in a new thread or in an existing pooled thread.
     * If the task cannot be submitted for execution, either because this
     * executor has been shutdown or because its capacity has been reached,
     * the task is handled by the current <tt>RejectedExecutionHandler</tt>.
     * @param command the task to execute
     * @throws RejectedExecutionException at discretion of
     * <tt>RejectedExecutionHandler</tt>, if task cannot be accepted
     * for execution
     * @throws NullPointerException if command is null
    public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {
            if (runState == RUNNING && workQueue.offer(command)) {
                if (runState != RUNNING || poolSize == 0)
                    ensureQueuedTaskHandled(command);
            else if (!addIfUnderMaximumPoolSize(command))
                reject(command); // is shutdown or saturated
     * Creates and starts a new thread running firstTask as its first
     * task, only if fewer than corePoolSize threads are running
     * and the pool is not shut down.
     * @param firstTask the task the new thread should run first (or
     * null if none)
     * @return true if successful
    private boolean addIfUnderCorePoolSize(Runnable firstTask) {
        Thread t = null;
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            if (poolSize < corePoolSize && runState == RUNNING)
                t = addThread(firstTask);
        } finally {
            mainLock.unlock();
        if (t == null)
            return false;
        t.start();
        return true;
     * Rechecks state after queuing a task. Called from execute when
     * pool state has been observed to change after queuing a task. If
     * the task was queued concurrently with a call to shutdownNow,
     * and is still present in the queue, this task must be removed
     * and rejected to preserve shutdownNow guarantees.  Otherwise,
     * this method ensures (unless addThread fails) that there is at
     * least one live thread to handle this task
     * @param command the task
    private void ensureQueuedTaskHandled(Runnable command) {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        boolean reject = false;
        Thread t = null;
        try {
            int state = runState;
            if (state != RUNNING && workQueue.remove(command))
                reject = true;
            else if (state < STOP &&
                     poolSize < Math.max(corePoolSize, 1) &&
                     !workQueue.isEmpty())
                t = addThread(null);
        } finally {
            mainLock.unlock();
        if (reject)
            reject(command);
        else if (t != null)
            t.start();
{code}