How to Create a Blocking ExecutorService in Java When the Queue Size is Reached?

How can I configure a Java ExecutorService to block submissions when the task queue size reaches a limit?

ThreadPoolExecutor executor = new ThreadPoolExecutor(numWorkerThreads, numWorkerThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>(maxQueue));

In Java, the ThreadPoolExecutor can be customized to handle task submissions when the queue is full without throwing rejected execution exceptions. Instead of allowing tasks to be rejected, we can implement a blocking mechanism for the submit operation to wait until capacity is available in the queue.

BlockingQueue<Runnable> blockingQueue = new ArrayBlockingQueue<>(maxQueue); // Blocking behavior on overflow
ThreadPoolExecutor executor = new ThreadPoolExecutor(numWorkerThreads, numWorkerThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  blockingQueue) {
    @Override
    public void beforeExecute(Thread t, Runnable r) {
        super.beforeExecute(t, r);
        try {
            if (blockingQueue.remainingCapacity() == 0) {
                // Block until there's space in the queue
                synchronized (this) {
                    while (blockingQueue.remainingCapacity() == 0) {
                        wait();
                    }
                }
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
};

Causes

• The `ExecutorService` is configured with a limited-sized queue.
• All worker threads are busy processing tasks, filling up the queue.
• Subsequent submissions may lead to the `RejectedExecutionException` if the queue reaches its limit.

Solutions

• Use a custom BlockingQueue that supports waiting on enqueue operations.
• Implement a wrapper around the `ExecutorService` to block the current thread until there is space in the queue.
• Consider using methods like `executor.awaitTermination()` after submitting tasks to manage the queue effectively.

Mistake: Using the default `CallerRunsPolicy`, which reverts execution to the calling thread, blocking further submissions.

Solution: Instead, implement a custom blocking strategy or use a dedicated blocking queue.

Mistake: Not handling `InterruptedException` when waiting on the queue.

Solution: Always check and handle thread interruption properly to ensure stability.