Class BoundedExecutorService

java.lang.Object

java.util.concurrent.AbstractExecutorService

org.apache.camel.util.concurrent.BoundedExecutorService

All Implemented Interfaces:

Executor, ExecutorService

public class BoundedExecutorService
extends AbstractExecutorService

An ExecutorService wrapper that enforces bounded concurrency via a Semaphore.

When virtual threads are enabled, Camel replaces the traditional ThreadPoolExecutor with Executors.newThreadPerTaskExecutor(), which accepts every task immediately (unbounded). This wrapper limits the maximum number of tasks delegated to the underlying executor. Unlike ThreadPoolExecutor there is no distinction between pool threads and queued tasks — the semaphore enforces a flat concurrency cap on delegated tasks.

When the semaphore has no available permits, behavior depends on the configured ThreadPoolRejectedPolicy:

• CallerRuns (default): blocks until a permit is available or the timeout expires; on timeout, runs the task on the caller's thread. Tasks are never lost. Note that caller-run tasks execute outside semaphore accounting, so total system concurrency may temporarily exceed maxConcurrent.
• Abort: blocks until a permit is available or the timeout expires; on timeout, throws RejectedExecutionException.
• Block: blocks indefinitely until a permit becomes available. No timeout, no rejection.

Caller thread blocking: while waiting for a permit, the calling thread is blocked. When callers are virtual threads this is inexpensive (the carrier thread is released). When callers are platform threads (e.g., HTTP server threads) the blocked thread is unavailable for other work — this is standard backpressure behavior but worth noting for capacity planning.

Constructor Summary

Constructors

Constructor	Description
BoundedExecutorService(ExecutorService delegate, int maxConcurrent, long acquireTimeout, TimeUnit timeUnit, boolean fair, ThreadPoolRejectedPolicy rejectedPolicy)

Method Summary

Modifier and Type	Method	Description
boolean	awaitTermination(long timeout, TimeUnit unit)
void	execute(Runnable command)
int	getActiveCount()	The number of tasks currently delegated to the underlying executor.
int	getAvailablePermits()	The number of permits currently available.
long	getCallerRunsCount()	The number of times the timeout expired and a task fell back to running on the caller's thread.
long	getDelegatedTaskCount()	The total number of tasks that completed via the underlying executor (excludes caller-runs).
int	getMaxConcurrent()	The maximum number of tasks that can be delegated to the underlying executor concurrently.
long	getRejectedCount()	The number of tasks rejected because no permit was available within the timeout.
int	getWaitingCount()	The number of threads currently blocked waiting for a permit.
boolean	isShutdown()
boolean	isTerminated()
protected <T> RunnableFuture<T>	newTaskFor(Runnable runnable, T value)
protected <T> RunnableFuture<T>	newTaskFor(Callable<T> callable)
void	shutdown()
List<Runnable>	shutdownNow()
String	toString()

Methods inherited from class AbstractExecutorService

invokeAll, invokeAll, invokeAny, invokeAny, submit, submit, submit

Methods inherited from class Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Constructor Details

BoundedExecutorService

public BoundedExecutorService(ExecutorService delegate,
 int maxConcurrent,
 long acquireTimeout,
 TimeUnit timeUnit,
 boolean fair,
 ThreadPoolRejectedPolicy rejectedPolicy)

Parameters:

delegate - the underlying executor (typically newThreadPerTaskExecutor)

maxConcurrent - the maximum number of tasks delegated to the underlying executor concurrently

acquireTimeout - the maximum time to wait for a permit (ignored when policy is Block)

timeUnit - the time unit for acquireTimeout

fair - true for FIFO permit ordering (predictable latency), false for barging (higher throughput)

rejectedPolicy - the policy to apply when no permit is available

Method Details

execute

public void execute(Runnable command)

getMaxConcurrent

public int getMaxConcurrent()

The maximum number of tasks that can be delegated to the underlying executor concurrently. CallerRuns tasks execute outside this limit.

getAvailablePermits

public int getAvailablePermits()

The number of permits currently available.

getActiveCount

public int getActiveCount()

The number of tasks currently delegated to the underlying executor.

getWaitingCount

public int getWaitingCount()

The number of threads currently blocked waiting for a permit.

getCallerRunsCount

public long getCallerRunsCount()

The number of times the timeout expired and a task fell back to running on the caller's thread.

getRejectedCount

public long getRejectedCount()

The number of tasks rejected because no permit was available within the timeout.

getDelegatedTaskCount

public long getDelegatedTaskCount()

The total number of tasks that completed via the underlying executor (excludes caller-runs).

newTaskFor

protected <T> RunnableFuture<T> newTaskFor(Runnable runnable,
 T value)

Overrides:

newTaskFor in class AbstractExecutorService

newTaskFor

protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable)

Overrides:

newTaskFor in class AbstractExecutorService

shutdown

public void shutdown()

shutdownNow

public List<Runnable> shutdownNow()

isShutdown

public boolean isShutdown()

isTerminated

public boolean isTerminated()

awaitTermination

public boolean awaitTermination(long timeout,
 TimeUnit unit)
                         throws InterruptedException

Throws:

InterruptedException

toString

public String toString()

Overrides:

toString in class Object