org.apache.camel.spi

Interface AsyncProcessorAwaitManager

All Superinterfaces:

Service, StaticService

All Known Implementing Classes:

DefaultAsyncProcessorAwaitManager

public interface AsyncProcessorAwaitManager
extends StaticService

A manager to handle async routing engine, when Exchanges are being handed over from one thread to another, while the callee thread is blocked waiting for the other threads to complete, before it can continue.

This manager offers insight into the state, and allow to force stuck exchanges to be continued and for blocked threads to be unblocked, which may happen in case of severe malfunctions (such as the system runs out of memory, a 3rd party never responding, or a timeout not triggering, etc).

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static interface	AsyncProcessorAwaitManager.AwaitThread Information about the thread and exchange that are inflight.
static interface	AsyncProcessorAwaitManager.Statistics Utilization statistics of the this manager.

Method Summary

Modifier and Type	Method and Description
void	await(Exchange exchange, CountDownLatch latch) Registers the exchange to await for the callback to be triggered by another thread which has taken over processing this exchange.
Collection<AsyncProcessorAwaitManager.AwaitThread>	browse() A read-only browser of the AsyncProcessorAwaitManager.AwaitThreads that are currently inflight.
void	countDown(Exchange exchange, CountDownLatch latch) Triggered when the other thread is done processing the exchange, to signal to the waiting thread is done, and can take over control to further process the exchange.
AsyncProcessorAwaitManager.Statistics	getStatistics() Gets the utilization statistics of this manager
void	interrupt(Exchange exchange) To interrupt an exchange which may seem as stuck, to force the exchange to continue, allowing any blocking thread to be released.
void	interrupt(String exchangeId) To interrupt an exchange which may seem as stuck, to force the exchange to continue, allowing any blocking thread to be released.
boolean	isInterruptThreadsWhileStopping() Whether to interrupt any blocking threads during stopping.
void	setInterruptThreadsWhileStopping(boolean interruptThreadsWhileStopping) Sets whether to interrupt any blocking threads during stopping.
int	size() Number of threads that are blocked waiting for other threads to trigger the callback when they are done processing the exchange.

Methods inherited from interface org.apache.camel.Service

start, stop

Method Detail

await

void await(Exchange exchange,
           CountDownLatch latch)

Registers the exchange to await for the callback to be triggered by another thread which has taken over processing this exchange. The current thread will await until that callback happens in the future (blocking until this happens).

Parameters:

exchange - the exchange

latch - the latch used to wait for other thread to signal when its done

countDown

void countDown(Exchange exchange,
               CountDownLatch latch)

Triggered when the other thread is done processing the exchange, to signal to the waiting thread is done, and can take over control to further process the exchange.

Parameters:

exchange - the exchange

latch - the latch used to wait for other thread to signal when its done

size

int size()

Number of threads that are blocked waiting for other threads to trigger the callback when they are done processing the exchange.

browse

Collection<AsyncProcessorAwaitManager.AwaitThread> browse()

A read-only browser of the AsyncProcessorAwaitManager.AwaitThreads that are currently inflight.

interrupt

void interrupt(String exchangeId)

To interrupt an exchange which may seem as stuck, to force the exchange to continue, allowing any blocking thread to be released.

Important: Use this with caution as the other thread is still assumed to be process the exchange. Though if it appears as the exchange is stuck, then this method can remedy this, by forcing the latch to count-down so the blocked thread can continue. An exception is set on the exchange which allows Camel's error handler to deal with this malfunctioned exchange.

Parameters:

exchangeId - the exchange id to interrupt.

interrupt

void interrupt(Exchange exchange)

To interrupt an exchange which may seem as stuck, to force the exchange to continue, allowing any blocking thread to be released.

Important: Use this with caution as the other thread is still assumed to be process the exchange. Though if it appears as the exchange is stuck, then this method can remedy this, by forcing the latch to count-down so the blocked thread can continue. An exception is set on the exchange which allows Camel's error handler to deal with this malfunctioned exchange.

Parameters:

exchange - the exchange to interrupt.

isInterruptThreadsWhileStopping

boolean isInterruptThreadsWhileStopping()

Whether to interrupt any blocking threads during stopping.

This is enabled by default which allows Camel to release any blocked thread during shutting down Camel itself.

setInterruptThreadsWhileStopping

void setInterruptThreadsWhileStopping(boolean interruptThreadsWhileStopping)

Sets whether to interrupt any blocking threads during stopping.

This is enabled by default which allows Camel to release any blocked thread during shutting down Camel itself.

getStatistics

AsyncProcessorAwaitManager.Statistics getStatistics()

Gets the utilization statistics of this manager

Returns:

the utilization statistics