import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;

public class QuickTest {
    public static void main(String[] args) throws InterruptedException {
    	//  LinkedBlockingQueue<Runnable> queue = new LinkedBlockingQueue<Runnable>();
        TaskQueue taskqueue = new TaskQueue();
        final ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 6, 60000, TimeUnit.MILLISECONDS, taskqueue);
        taskqueue.setParent((ThreadPoolExecutor) executor);

        for (int i = 0; i < 100; i++) {
            System.out.println("Submit " + (i + 1) + " task to executor..");
            executor.submit(new Runnable() {

                @Override
                public void run() {
                    for (int j = 0; j < 10; j++) {
                        System.out.println(executor.toString());
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                }
            });
        }

        Thread.currentThread().join();
    }
}

package org.apache.tomcat.util.threads;

import java.util.Collection;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.TimeUnit;

/**
 * As task queue specifically designed to run with a thread pool executor.
 * The task queue is optimised to properly utilize threads within
 * a thread pool executor. If you use a normal queue, the executor will spawn threads
 * when there are idle threads and you wont be able to force items unto the queue itself
 * @author fhanik
 *
 */
public class TaskQueue extends LinkedBlockingQueue<Runnable> {

    private static final long serialVersionUID = 1L;

    private ThreadPoolExecutor parent = null;

    // no need to be volatile, the one times when we change and read it occur in
    // a single thread (the one that did stop a context and fired listeners)
    private Integer forcedRemainingCapacity = null;

    public TaskQueue() {
        super();
    }

    public TaskQueue(int capacity) {
        super(capacity);
    }

    public TaskQueue(Collection<? extends Runnable> c) {
        super(c);
    }

    public void setParent(ThreadPoolExecutor tp) {
        parent = tp;
    }

    ...

    @Override
    public boolean offer(Runnable o) {
	    // we can't do any checks
	    if (parent==null) return super.offer(o);
	    // we are maxed out on threads, simply queue the object
	    if (parent.getPoolSize() == parent.getMaximumPoolSize()) return super.offer(o);
	    // we have idle threads, just add it to the queue
	    if (parent.getSubmittedCount()<(parent.getPoolSize())) return super.offer(o);
	    // if we have less threads than maximum force creation of a new thread
	    if (parent.getPoolSize()<parent.getMaximumPoolSize()) return false;
	    // if we reached here, we need to add it to the queue
	    return super.offer(o);
    }

    ...

}