javax.realtime

Class FirstInFirstOutReleaseRunner

java.lang.Object

javax.realtime.ReleaseRunner

javax.realtime.FirstInFirstOutReleaseRunner

public class FirstInFirstOutReleaseRunner
extends ReleaseRunner

The default ReleaseRunner that uses a pool of FIFO scheduled realtime threads to run handlers. This reduces the amount of threads required for handling events compared with bounding a thread to each handler. It also supports handlers that suspend themselves, e.g., by calling the Object.wait() method. The size of the pool of threads is based on the number of handlers, the number of priorities in use, and the number of cpus available. For systems with many AsyncBaseEventHandler instances, there can be significantly fewer threads to run releases of those handlers in the system.

Since:

RTSJ 2.0

Nested Class Summary

Nested classes/interfaces inherited from class javax.realtime.ReleaseRunner

ReleaseRunner.Proxy

Constructor Summary

Constructors

Constructor and Description
FirstInFirstOutReleaseRunner(ConfigurationParameters config) Same as FirstInFirstOutReleaseRunner(ConfigurationParameters, RealtimeThreadGroup, IntBinaryOperator) with arguments {(config, null, null)}.
FirstInFirstOutReleaseRunner(ConfigurationParameters config, RealtimeThreadGroup group, java.util.function.IntBinaryOperator sizer) Create a release runner which maintains a pool of threads to run releases of AsyncBaseEventHandler instances.

Method Summary

Modifier and Type	Method and Description
protected void	attach(ReleaseRunner.Proxy handler) Attach a handler from this runner, so it will be released.
protected void	detach(ReleaseRunner.Proxy handler) Detach a handler from this runner, so it will no longer be released.
ConfigurationParameters	getConfigurationParameters() Get the ConfigurationParameters object used for all threads provided by this release runner.
protected RealtimeThreadGroup	getRealtimeThreadGroup() Determine the RealtimeThreadGroup instance used.
protected void	release(ReleaseRunner.Proxy handler) Finds a thread and has it call the Runnable.run() method.

Methods inherited from class java.lang.Object

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

Constructor Detail

FirstInFirstOutReleaseRunner

public FirstInFirstOutReleaseRunner(ConfigurationParameters config,
                                    RealtimeThreadGroup group,
                                    java.util.function.IntBinaryOperator sizer)

Create a release runner which maintains a pool of threads to run releases of AsyncBaseEventHandler instances. The threads in the pool all run in a given RealtimeThreadGroup instance. The thread pool size is determined by the binary function sizer. When sizer is null, a reasonable default is provided.

Parameters:

config - the ConfigurationParameters object to use for all handler run from this pool, which means for each thread in the pool.

group - for the pool threads.

sizer - A binary function from the number of handlers and the number of priorities of those handles to the number of threads in the pool. It may use global information, such as the number of available CPUs. It may also ignore its arguments.

FirstInFirstOutReleaseRunner

public FirstInFirstOutReleaseRunner(ConfigurationParameters config)

Same as FirstInFirstOutReleaseRunner(ConfigurationParameters, RealtimeThreadGroup, IntBinaryOperator) with arguments {(config, null, null)}.

Method Detail

getRealtimeThreadGroup

protected RealtimeThreadGroup getRealtimeThreadGroup()

Description copied from class: ReleaseRunner

Determine the RealtimeThreadGroup instance used.

Specified by:

getRealtimeThreadGroup in class ReleaseRunner

Returns:

the RealtimeThreadGroup instance used by all threads used for running releases.

getConfigurationParameters

public ConfigurationParameters getConfigurationParameters()

Description copied from class: ReleaseRunner

Get the ConfigurationParameters object used for all threads provided by this release runner.

Specified by:

getConfigurationParameters in class ReleaseRunner

Returns:

those parameters.

release

protected void release(ReleaseRunner.Proxy handler)

Description copied from class: ReleaseRunner

Finds a thread and has it call the Runnable.run() method. Care should be exercised when implementing this method, since it adds to both the latency and jitter of releasing events. The caller must guarantee that releases of any given handler are always executed in order.

This method should only be called from the infrastructure.

Specified by:

release in class ReleaseRunner

Parameters:

handler - The handler to be released.

attach

protected void attach(ReleaseRunner.Proxy handler)
               throws StaticIllegalStateException

Attach a handler from this runner, so it will be released. Adjusts the number of threads for running handlers accordingly.

Specified by:

attach in class ReleaseRunner

Parameters:

handler - to be removed.

Throws:

StaticIllegalArgumentException - When handler is null

StaticIllegalStateException - when handler is already attached.

detach

protected void detach(ReleaseRunner.Proxy handler)
               throws StaticIllegalStateException

Detach a handler from this runner, so it will no longer be released. Adjusts the number of threads for running handlers accordingly.

Specified by:

detach in class ReleaseRunner

Parameters:

handler - to be detached.

Throws:

StaticIllegalArgumentException - When handler is null

StaticIllegalStateException - when handler is not attached.