I'll admit that my suggestion is not particularly elegant in terms of  
implementation.  However, I think there is something to be said for  
encapsulating this behaviour within the queue implementation, particularly  
if you want to re-use it, since you won't have to worry about setting a  
RejectedExecutionHandler on every thread pool you create.  So I'm  
convinced that the custom queue implementation is the right approach, but  
the question remains as to what form should that implementation take,  
whether you should write something from scratch or adapt one of the  
existing implementations (presumably SynchronousQueue or  
ArrayBlockingQueue).

I'd overlooked the put method but, now that you mention it, I think this  
has to be better than my suggestion of fudging the issue by calling offer  
with a long timeout (unless, of course, you want a timeout).  There is  
nothing in the API documentation that suggests that a blocking  
implementation of offer would be a bad thing.

Dan.

You are absolutely right, sorry, must have been experiencing a mental
haywire when I wrote that code yesterday. It is probably best ignored.

I dont think it was the model intended for implementing blocking
executors. It probably is the model intended to inform a process that a
task it provided cannot be executed due to heavy load (all threads
busy, and pool at maximum).

Sure, but there is nothing there that says explicitally that 'offer'
cannot block, Dan mentioned this before. The ThreadPoolExecutor uses
queue.offer rather than queue.put when execute is called, so you need
offer to block. You could write an ArrayBlockingQueue subclass to
redirect all calls to 'offer' to 'put' which would have the desired
effect. I think I would prefer something like this....

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.Collection;

public class DefaultedOfferTimeoutBlockingQueue<E> extends
ArrayBlockingQueue<E>
{
   private long defaultOfferTimeoutDuration;
   private TimeUnit defaultOfferTimeUnit;

   public DefaultedOfferTimeoutBlockingQueue(int capacity, long
defaultOfferTimeoutDuration, TimeUnit defaultOfferTimeUnit)
   {
       super(capacity);
       this.defaultOfferTimeoutDuration = defaultOfferTimeoutDuration;
       this.defaultOfferTimeUnit = defaultOfferTimeUnit;
   }

   public DefaultedOfferTimeoutBlockingQueue(int capacity, boolean
fair, long defaultOfferTimeoutDuration, TimeUnit defaultOfferTimeUnit)
   {
       super(capacity, fair);
       this.defaultOfferTimeoutDuration = defaultOfferTimeoutDuration;
       this.defaultOfferTimeUnit = defaultOfferTimeUnit;
   }

   public DefaultedOfferTimeoutBlockingQueue(int capacity, boolean
fair, Collection<? extends E> initialElements, long
defaultOfferTimeoutDuration, TimeUnit defaultOfferTimeUnit)
   {
       super(capacity, fair, initialElements);
       this.defaultOfferTimeoutDuration = defaultOfferTimeoutDuration;
       this.defaultOfferTimeUnit = defaultOfferTimeUnit;
   }

   public boolean offer(E element)
   {
       try
       {
           return offer(element, defaultOfferTimeoutDuration,
defaultOfferTimeUnit);
       }
       catch (InterruptedException e)
       {
           //todo: probably should log something here
           return false;
       }
   }
}

Which is a simple blocking queue that lets you create a default timeout
for the basic 'offer' method (rather than it failing instantly).

With this class in place you can simply do this...

import java.util.concurrent.Executor;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadPoolExecutorBlockTest
{
   public static void main(String[] args)
   {
       Executor executor = new ThreadPoolExecutor(5, 10, 10,
TimeUnit.SECONDS, new DefaultedOfferTimeoutBlockingQueue<Runnable>(5,
86400, TimeUnit.SECONDS));

       for(int i = 0; i < 50; i++)
       {
           executor.execute(new Printer(i));
           System.out.println("Task " + i + " added");
       }
   }

   private static class Printer implements Runnable
   {
       private int number;

       public Printer(int number)
       {
           this.number = number;
       }

       public void run()
       {
           System.out.println("Running task: " + number);
           try
           {
               Thread.sleep(10000);
           }
           catch (InterruptedException e)
           {
               e.printStackTrace();
           }
       }
   }
}

This seems to work very well for me.

Note though, items are removed from the queue (freeing up space) before
the task is run and not after, so there will always be (queueSize +
threadPoolSize) tasks that are sitting in the executor.