Blocking ThreadPoolExecutor

Question

Hi,
I'd like to use ThreadPoolExecutor to manage a set number of threads that I have for executing tasks, and have clients of the executor block when all threads in the pool are busy.
So, in the code below, the first three calls to execute() will cause the Runnable to be executed, but the fourth will block until one of the first three calls completes.
ThreadPoolExecutor executor = new ThreadPoolExecutor( 0, 3, 0, TimeUnit.MILLISECONDS( 3, 3, 0L, TimeUnit.MILLISECONDS, new SynchronousQueue<Runnable>() );
while ( true ) {
    executor.execute( new Runnable() {
        public void run() {
             // do something
}However I can't seem to find any way of doing this - I always just get a RejectedExecutionException (or if I use a different RejectedExecutionHandler.DiscardPolicy the while loop just spins continuously, occasionally successfully executing a job). Any ideas?

Answer 1

Thanks for the replys.
I looked at using a custom RejectedExecutionHandler but then realised I could actually do what I needed less verbosely like this:
public class BlockingThreadPoolExecutor extends ThreadPoolExecutor {
    private final Semaphore semaphore;
    public BlockingThreadPoolExecutor( int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue ) {
        super( corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue );
        semaphore = new Semaphore( maximumPoolSize, true );
    @Override
    public void execute( Runnable command ) {
        try {
            semaphore.acquire();
        } catch ( InterruptedException e ) {}
        super.execute( command );
    @Override
    protected void afterExecute( Runnable command, Throwable t ) {
        semaphore.release();
}This works - almost. Unfortunately there is a race condition which means an execution will still be rejected with the following :
1. three tasks are entered & begin execution on threads A,B and C
2. thread D submites a fourth task and blocks in execute(), waiting to aquire a permit
3. thread A completes its task and calls afterExecute(), releasing a permit
4. D aquires a permit and calls super.execute()
5. D offers its task to the workQueue BEFORE the thread A either dies or calls take() on the workQueue
Note that implementing the solution using a RejectedExecutionHandler makes no difference - the problem is to do with there being a small amount of work done after the call to afterExecute() which applies in this case also.
Can't see away round it, which sucks, so I'm probably going to give up using ThreadPoolExecutor unless anyone has any good ideas?