javax.realtime

Class AsyncBaseEventHandler

java.lang.Object

javax.realtime.AsyncBaseEventHandler

All Implemented Interfaces:

Runnable, Releasable<Timable,TimeDispatcher>, Schedulable, Subsumable<Schedulable>, Timable

Direct Known Subclasses:

AsyncEventHandler, AsyncLongEventHandler, AsyncObjectEventHandler

public abstract class AsyncBaseEventHandler
extends Object
implements Schedulable

This is the base class for all event handlers.

An instance of this class contains code that will be released for execution when an asynchronous event occurs.

If an event occurs multiple times, the releases of one event handler will be serialized, i.e., one event handler will never be released more than once simultaneously. However, one event that is attached to several handlers can cause the simultaneous release of several event handlers.

If the release parameters associated with this handler are SporadicParameters, then the minimum interarrival time specified in these parameters will be enforced. The deadline specified is always relative to the fire time, even if the actual release time may be later to enforce the minimum interarrival time.

Handlers run in the context of a RealtimeThread, they may run for short or long times and they may block. Note that a handler that is blocked may block all other handlers with the same scheduling parameters since these handlers may share one instance of RealtimeThread. A handler may not call RealtimeThread.waitForNextPeriod().

Several handlers share a common set of RealtimeThreads for their execution. This causes some additional overhead when releasing a handler and it may cause a delayed execution if a handler with equal scheduling parameters is blocked during execution. To avoid these delays, handlers of type BoundSchedulable may be used, these handlers are bound to their own RealtimeThread for execution, but they require more system resources (threads and memory).

A AsyncBaseEventHandler may make use of memory areas just as a RealtimeThread does.

Since:

RTSJ V1.1

Method Summary

Modifier and Type	Method and Description
boolean	addIfFeasible() addIfFeasible adds this to the feasibility analysis of the associated scheduler if the resulting system will be feasible.
boolean	addToFeasibility() addToFeasibility notifies the scheduler associated with this that this schedulable object's scheduling, release, memory, and processing group parameters take part in the feasibility analysis.
protected void	finalize() finalizer to release and terminate execution thread that is not needed any longer.
protected int	getAndClearPendingFireCount() Set the pending fire count to zero and returns the original value.
protected int	getAndDecrementPendingFireCount() Decrements the pending fire count and returns the original value.
TimeDispatcher	getDispatcher() Gets the dispatcher associated with this Timable.
MemoryArea	getMemoryArea() getMemoryArea returns the initial memory area provided to the constructor of this handler.
MemoryParameters	getMemoryParameters() getMemoryParameters returns a reference to the MemoryParameters of this AsyncBaseEventHandler.
protected int	getPendingFireCount() getPendingFireCount returns the current number of pending invocations to handleAsyncEvent().
ProcessingGroupParameters	getProcessingGroupParameters() getProcessingGroupParameters returns the current ProcessingGroupParameters of this AsyncBaseEventHandler.
ReleaseParameters<?>	getReleaseParameters() getReleaseParameters returns the current ReleaseParameters of this AsyncBaseEventHandler.
Scheduler	getScheduler() getScheduler returns the current scheduler of this handler.
SchedulingParameters	getSchedulingParameters() getSchedulingParameters returns the SchedulingParameters of this handler.
boolean	isDaemon() Check if this is a daemon handler, i.e., one that does not keep the VM from exiting.
boolean	mayUseHeap() Determines whether or not this schedulable may use the heap.
boolean	removeFromFeasibility() removeFromFeasibility informs the scheduler associated with this AsyncBaseEventHandler that this AsyncBaseEventHandler should no longer be taken into account in the feasibility analysis.
void	run() Calls handleAsyncEvent repeatedly until the fire count reaches zero.
void	setDaemon(boolean on) Mark this handler as daemon or non-daemon.
boolean	setIfFeasible(ReleaseParameters<?> release, MemoryParameters memory) setIfFeasible performs a feasibility analysis using the provided release and memory parameters.
boolean	setIfFeasible(ReleaseParameters<?> release, MemoryParameters memory, ProcessingGroupParameters group) setIfFeasible performs a feasibility analysis using the provided release, memory, and processing group parameters.
boolean	setIfFeasible(ReleaseParameters<?> release, ProcessingGroupParameters group) setIfFeasible performs a feasibility analysis using the provided release and processing group parameters.
boolean	setIfFeasible(SchedulingParameters sched, ReleaseParameters<?> release, MemoryParameters memory) setIfFeasible performs a feasibility analysis using the provided scheduling, release and memory parameters.
boolean	setIfFeasible(SchedulingParameters sched, ReleaseParameters<?> release, MemoryParameters memory, ProcessingGroupParameters group) setIfFeasible performs a feasibility analysis using the provided scheduling, release, memory, and processing group parameters.
Schedulable	setMemoryParameters(MemoryParameters memory) setMemoryParameters replaces the memory parameters for this handler with the parameters provided.
boolean	setMemoryParametersIfFeasible(MemoryParameters memory) setMemoryParametersIfFeasible performs a feasibility analysis using the provided memory parameters.
void	setProcessingGroupParameters(ProcessingGroupParameters group) setProcessingGroupParameters sets the processing group parameters of this handler.
boolean	setProcessingGroupParametersIfFeasible(ProcessingGroupParameters group) setProcessingGroupParametersIfFeasible performs a feasibility analysis using the provided processing group parameters.
Schedulable	setReleaseParameters(ReleaseParameters<?> release) setReleaseParameters replaces the release parameters for this handler with the parameters provided.
boolean	setReleaseParametersIfFeasible(ReleaseParameters<?> release) setReleaseParametersIfFeasible performs a feasibility analysis using the provided release parameters.
Schedulable	setScheduler(Scheduler scheduler) setScheduler sets the scheduler for this handler.
void	setScheduler(Scheduler scheduler, SchedulingParameters scheduling, ReleaseParameters<?> release, MemoryParameters memory, ProcessingGroupParameters group) setScheduler sets the scheduler and scheduling, release, memory, and processing group parameters for this handler.
Schedulable	setSchedulingParameters(SchedulingParameters scheduling) setSchedulingParameters sets the scheduling parameters for this Schedulable.
boolean	setSchedulingParametersIfFeasible(SchedulingParameters scheduling) setSchedulingParametersIfFeasible performs a feasibility analysis using the provided scheduling parameters.
boolean	subsumes(Schedulable other) Determine whether or not this instance of Schedulable is more eligible than other.

Methods inherited from class java.lang.Object

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

Method Detail

getPendingFireCount

protected int getPendingFireCount()

getPendingFireCount returns the current number of pending invocations to handleAsyncEvent(). During the execution of handleAsyncEvent(), the fire count is at least 1 unless it has been reset manually (by a call to getAndClearPendingFireCount() or getAndDecrementPendingFireCount()).

Returns:

The current number of pending executions of handleAsyncEvent().

getAndClearPendingFireCount

protected int getAndClearPendingFireCount()

Set the pending fire count to zero and returns the original value. It is not thread safe and should only be used in the context of handleAsyncEvent.

Returns:

the original fire count.

getAndDecrementPendingFireCount

protected int getAndDecrementPendingFireCount()

Decrements the pending fire count and returns the original value. It is not thread safe and should only be used in the context of handleAsyncEvent.

Returns:

the original fire count.

isDaemon

public final boolean isDaemon()

Check if this is a daemon handler, i.e., one that does not keep the VM from exiting. By default, all newly created handlers are daemon handlers unless they are turned into non-daemon handlers explicitly by a call to setDaemon(false).

Specified by:

isDaemon in interface Schedulable

Returns:

true iff this is a daemon handler.

Since:

RTSJ V1.0.1

mayUseHeap

public boolean mayUseHeap()

Determines whether or not this schedulable may use the heap.

Specified by:

mayUseHeap in interface Schedulable

Returns:

true only when this Schedulable may allocate on the heap and may enter the Heap.

Since:

RTSJ 2.0

setDaemon

public final void setDaemon(boolean on)

Mark this handler as daemon or non-daemon. Non-Daemon event handlers prevent the VM from exiting as long as they run. This must be called before this handler is attached to an event, the state cannot be changed later.

By default, all newly created handlers are daemon handler unless they are turned into non-daemon handlers explicitly by a call to setDaemon(false).

Specified by:

setDaemon in interface Schedulable

Throws:

IllegalTaskStateException - if this handler is attached to an async event.

SecurityException - if this change is not allowed for the current schedulable object.

Parameters:

on - true to select daemon state, false for non-daemon state.

Since:

RTSJ V1.0.1

getMemoryArea

public MemoryArea getMemoryArea()

getMemoryArea returns the initial memory area provided to the constructor of this handler. If none was provided, the default is the current allocation context when this was constructed.

Returns:

the initial memory area of this handler.

addToFeasibility

public boolean addToFeasibility()

addToFeasibility notifies the scheduler associated with this that this schedulable object's scheduling, release, memory, and processing group parameters take part in the feasibility analysis.

In case this schedulable object is already part of the feasibility analysis, do nothing.

Specified by:

addToFeasibility in interface Schedulable

Returns:

true iff the resulting system is feasible.

addIfFeasible

public boolean addIfFeasible()

addIfFeasible adds this to the feasibility analysis of the associated scheduler if the resulting system will be feasible.

If the object is already included in the feasible set, do nothing.

Specified by:

addIfFeasible in interface Schedulable

Returns:

true iff this was admitted to the feasible set. false if this was not admitted or if this was already part of the feasible set.

setIfFeasible

public boolean setIfFeasible(ReleaseParameters<?> release,
                             MemoryParameters memory)
                      throws StaticIllegalArgumentException,
                             IllegalAssignmentError,
                             IllegalThreadStateException

setIfFeasible performs a feasibility analysis using the provided release and memory parameters. If the system remains feasible with these new parameters, the parameters are replaced.

If this object is not a member of the feasible set of the scheduler and the resulting system is feasible, this will be added to the set.

Specified by:

setIfFeasible in interface Schedulable

Throws:

StaticIllegalArgumentException - if the parameter values are not compatible with the scheduler associated to this AsyncBaseEventHandler.

IllegalAssignmentError - if release or memory and this reside in memory areas whose objects cannot refer to one another (in both directions).

IllegalThreadStateException - If the old release parameters are periodic, the new release parameters are not periodic, and the schedulable object is currently blocked in waitForNextPeriod or waitForNextPeriodInterruptible.

Parameters:

release - the new release parameters. If null, the default value for the associated scheduler will be used.

memory - the new memory parameters. If null, the default value for the associated scheduler will be used.

Returns:

true iff the resulting system is feasible and the new release and memory parameters have been activated. false if the resulting system is not feasible, no changes are made in this case.

setIfFeasible

public boolean setIfFeasible(SchedulingParameters sched,
                             ReleaseParameters<?> release,
                             MemoryParameters memory)
                      throws StaticIllegalArgumentException,
                             IllegalAssignmentError,
                             IllegalThreadStateException

setIfFeasible performs a feasibility analysis using the provided scheduling, release and memory parameters. If the system remains feasible with these new parameters, the scheduling, release, and memory parameters are replaced.

If this object is not a member of the feasible set of the scheduler and the resulting system is feasible, this will be added to the set.

Specified by:

setIfFeasible in interface Schedulable

Throws:

StaticIllegalArgumentException - if the parameter values are not compatible with the scheduler associated to this AsyncBaseEventHandler.

IllegalAssignmentError - if sched, release or memory and this reside in memory areas whose objects cannot refer to one another (in both directions).

IllegalThreadStateException - If the old release parameters are periodic, the new release parameters are not periodic, and the schedulable object is currently blocked in waitForNextPeriod or waitForNextPeriodInterruptible.

Parameters:

sched - the new scheduling parameters. If null, the default value of the associated scheduler will be used. This default value may be null.

release - the new release parameters. If null, the default value for the associated scheduler will be used.

memory - the new memory parameters. If null, the default value for the associated scheduler will be used.

Returns:

true iff the resulting system is feasible and the new release and memory parameters have been activated. false if the resulting system is not feasible, no changes are made in this case.

Since:

RTSJ V1.0.1

setIfFeasible

public boolean setIfFeasible(ReleaseParameters<?> release,
                             MemoryParameters memory,
                             ProcessingGroupParameters group)
                      throws StaticIllegalArgumentException,
                             IllegalAssignmentError,
                             IllegalThreadStateException

setIfFeasible performs a feasibility analysis using the provided release, memory, and processing group parameters. If the system remains feasible with these new parameters, the parameters are replaced.

If this object is not a member of the feasible set of the scheduler and the resulting system is feasible, this will be added to the set.

Specified by:

setIfFeasible in interface Schedulable

Throws:

StaticIllegalArgumentException - if the parameter values are not compatible with the scheduler associated to this AsyncBaseEventHandler.

IllegalAssignmentError - if release, memory or group and this reside in memory areas whose objects cannot refer to one another (in both directions).

IllegalThreadStateException - If the old release parameters are periodic, the new release parameters are not periodic, and the schedulable object is currently blocked in waitForNextPeriod or waitForNextPeriodInterruptible.

Parameters:

release - the new release parameters. If null, the default value for the associated scheduler will be used.

memory - the new memory parameters. If null, the default value for the associated scheduler will be used.

group - the new processing group parameters. If null, the default value for the associated scheduler will be used.

Returns:

true iff the resulting system is feasible and the new release, memory, and group parameters have been activated. false if the resulting system is not feasible, no changes are made in this case.

setIfFeasible

public boolean setIfFeasible(SchedulingParameters sched,
                             ReleaseParameters<?> release,
                             MemoryParameters memory,
                             ProcessingGroupParameters group)
                      throws StaticIllegalArgumentException,
                             IllegalAssignmentError,
                             IllegalThreadStateException

setIfFeasible performs a feasibility analysis using the provided scheduling, release, memory, and processing group parameters. If the system remains feasible with these new parameters, the scheduling, release, memory, and processing group parameters are replaced.

If this object is not a member of the feasible set of the scheduler and the resulting system is feasible, this will be added to the set.

Specified by:

setIfFeasible in interface Schedulable

Throws:

StaticIllegalArgumentException - if the parameter values are not compatible with the scheduler associated to this AsyncBaseEventHandler.

IllegalAssignmentError - if sched, release, memory or group and this reside in memory areas whose objects cannot refer to one another (in both directions).

IllegalThreadStateException - If the old release parameters are periodic, the new release parameters are not periodic, and the schedulable object is currently blocked in waitForNextPeriod or waitForNextPeriodInterruptible.

Parameters:

sched - the new scheduling parameters. If null, the default value of the associated scheduler will be used. This default value may be null.

release - the new release parameters. If null, the default value for the associated scheduler will be used.

memory - the new memory parameters. If null, the default value for the associated scheduler will be used.

group - the new processing group parameters. If null, the default value for the associated scheduler will be used.

Returns:

true iff the resulting system is feasible and the new scheduling, release, memory, and group parameters have been activated. false if the resulting system is not feasible, no changes are made in this case.

setReleaseParametersIfFeasible

public boolean setReleaseParametersIfFeasible(ReleaseParameters<?> release)
                                       throws IllegalThreadStateException

setReleaseParametersIfFeasible performs a feasibility analysis using the provided release parameters. If the system remains feasible with the new parameters, the parameters are replaced.

If this object is not a member of the feasible set of the scheduler and the resulting system is feasible, this will be added to the set.

Specified by:

setReleaseParametersIfFeasible in interface Schedulable

Throws:

StaticIllegalArgumentException - if the parameter values are not compatible with the scheduler associated to this AsyncBaseEventHandler.

IllegalAssignmentError - if release and this reside in memory areas whose objects cannot refer to one another (in both directions).

IllegalThreadStateException - If the old release parameters are periodic, the new release parameters are not periodic, and the schedulable object is currently blocked in waitForNextPeriod or waitForNextPeriodInterruptible.

Parameters:

release - the new release parameters. If null, the default value for the associated scheduler will be used.

Returns:

true iff the resulting system is feasible and the new release parameters have been activated. false if the resulting system is not feasible, no changes are made in this case.

setProcessingGroupParametersIfFeasible

public boolean setProcessingGroupParametersIfFeasible(ProcessingGroupParameters group)

setProcessingGroupParametersIfFeasible performs a feasibility analysis using the provided processing group parameters. If the system remains feasible with these new parameters, parameters are replaced.

If this object is not a member of the feasible set of the scheduler and the resulting system is feasible, this will be added to the set.

Specified by:

setProcessingGroupParametersIfFeasible in interface Schedulable

Throws:

StaticIllegalArgumentException - if the group parameter value is not compatible with the scheduler associated to this AsyncBaseEventHandler.

IllegalAssignmentError - If group and this reside in memory areas whose objects cannot refer to one another (in both directions).

Parameters:

group - the new processing group parameters. If null, the default value for the associated scheduler will be used.

Returns:

true iff the resulting system is feasible and the new group parameters have been activated. false if the resulting system is not feasible, no changes are made in this case.

setIfFeasible

public boolean setIfFeasible(ReleaseParameters<?> release,
                             ProcessingGroupParameters group)
                      throws StaticIllegalArgumentException,
                             IllegalAssignmentError,
                             IllegalThreadStateException

setIfFeasible performs a feasibility analysis using the provided release and processing group parameters. If the system remains feasible with these new parameters, the parameters are replaced.

If this object is not a member of the feasible set of the scheduler and the resulting system is feasible, this will be added to the set.

Specified by:

setIfFeasible in interface Schedulable

Throws:

StaticIllegalArgumentException - if the parameter values are not compatible with the scheduler associated to this AsyncBaseEventHandler.

IllegalAssignmentError - if release or group and this reside in memory areas whose objects cannot refer to one another (in both directions).

IllegalThreadStateException - If the old release parameters are periodic, the new release parameters are not periodic, and the schedulable object is currently blocked in waitForNextPeriod or waitForNextPeriodInterruptible.

Parameters:

release - the new release parameters. If null, the default value for the associated scheduler will be used.

group - the new processing group parameters. If null, the default value for the associated scheduler will be used.

Returns:

true iff the resulting system is feasible and the new release and group parameters have been activated. false if the resulting system is not feasible, no changes are made in this case.

setMemoryParametersIfFeasible

public boolean setMemoryParametersIfFeasible(MemoryParameters memory)

setMemoryParametersIfFeasible performs a feasibility analysis using the provided memory parameters. If the system remains feasible with the new memory parameters, the parameters are replaced.

In JamaicaVM, this change becomes effective immediately.

If this object is not a member of the feasible set of the scheduler and the resulting system is feasible, this will be added to the set.

Specified by:

setMemoryParametersIfFeasible in interface Schedulable

Throws:

StaticIllegalArgumentException - if the memory parameter value is not compatible with the scheduler associated to this AsyncBaseEventHandler.

IllegalAssignmentError - if memory and this reside in memory areas whose objects cannot refer to one another (in both directions).

Parameters:

memory - the new memory parameters. If null, the default value for the associated scheduler will be used.

Returns:

true iff the resulting system is feasible and the new release, memory, and group parameters have been activated. false if the resulting system is not feasible, no changes are made in this case.

getMemoryParameters

public MemoryParameters getMemoryParameters()

getMemoryParameters returns a reference to the MemoryParameters of this AsyncBaseEventHandler.

Specified by:

getMemoryParameters in interface Schedulable

Returns:

the MemoryParameters of this AsyncBaseEventHandler.

getReleaseParameters

public ReleaseParameters<?> getReleaseParameters()

getReleaseParameters returns the current ReleaseParameters of this AsyncBaseEventHandler.

Specified by:

getReleaseParameters in interface Schedulable

Returns:

the ReleaseParameters.

getScheduler

public Scheduler getScheduler()

getScheduler returns the current scheduler of this handler.

Specified by:

getScheduler in interface Schedulable

Returns:

the scheduler.

getSchedulingParameters

public SchedulingParameters getSchedulingParameters()

getSchedulingParameters returns the SchedulingParameters of this handler.

Specified by:

getSchedulingParameters in interface Schedulable

Returns:

the SchedulingParameters.

getProcessingGroupParameters

public ProcessingGroupParameters getProcessingGroupParameters()

getProcessingGroupParameters returns the current ProcessingGroupParameters of this AsyncBaseEventHandler.

Specified by:

getProcessingGroupParameters in interface Schedulable

Returns:

the ProcessingGroupParameters

removeFromFeasibility

public boolean removeFromFeasibility()

removeFromFeasibility informs the scheduler associated with this AsyncBaseEventHandler that this AsyncBaseEventHandler should no longer be taken into account in the feasibility analysis.

Specified by:

removeFromFeasibility in interface Schedulable

Returns:

true iff this could be removed successfully, false iff this was not part of the feasible set of the assigned scheduler.

setMemoryParameters

public Schedulable setMemoryParameters(MemoryParameters memory)
                                throws IllegalThreadStateException

setMemoryParameters replaces the memory parameters for this handler with the parameters provided.

This change may change the feasibility of the current feasible set of this handler's scheduler.

In JamaicaVM, this change becomes effective at the next release of the handler.

Specified by:

setMemoryParameters in interface Schedulable

Throws:

StaticIllegalArgumentException - if the memory parameter value is not compatible with the scheduler associated to this AsyncBaseEventHandler.

IllegalAssignmentError - if memory and this reside in memory areas whose objects cannot refer to one another (in both directions).

IllegalThreadStateException

Parameters:

memory - the new memory parameters. If null, the default value for the associated scheduler will be used.

Since:

RTSJ 2.0 returns itself

setReleaseParameters

public Schedulable setReleaseParameters(ReleaseParameters<?> release)
                                 throws IllegalThreadStateException

setReleaseParameters replaces the release parameters for this handler with the parameters provided.

This change may change the feasibility of the current feasible set of this handler's scheduler.

Specified by:

setReleaseParameters in interface Schedulable

Throws:

StaticIllegalArgumentException - if the release parameter value is not compatible with the scheduler associated to this AsyncBaseEventHandler.

IllegalAssignmentError - if release and this reside in memory areas whose objects cannot refer to one another (in both directions).

IllegalThreadStateException - If the old release parameters are periodic, the new release parameters are not periodic, and the schedulable object is currently blocked in waitForNextPeriod or waitForNextPeriodInterruptible.

Parameters:

release - the new release parameters. If null, the default value for the associated scheduler will be used.

Since:

RTSJ 2.0 returns itself

setScheduler

public void setScheduler(Scheduler scheduler,
                         SchedulingParameters scheduling,
                         ReleaseParameters<?> release,
                         MemoryParameters memory,
                         ProcessingGroupParameters group)
                  throws StaticIllegalArgumentException,
                         IllegalAssignmentError,
                         IllegalThreadStateException,
                         SecurityException

setScheduler sets the scheduler and scheduling, release, memory, and processing group parameters for this handler.

The change of the scheduler and the scheduling and memory parameters will be immediate for the default scheduler. release, and processing group parameters will take effect on the next release.

This change may change the feasibility of the current feasible set of this handler's scheduler.

Specified by:

setScheduler in interface Schedulable

Throws:

StaticIllegalArgumentException - if scheduler is null or the scheduling, release, memory, or processing group parameters are not compatible with the scheduler.

IllegalAssignmentError - if scheduler, scheduling, release, memory, or group reside in memory areas whose objects cannot be referred to by this or this object resides in a memory area that cannot be referenced by scheduling, release, or memory.

IllegalThreadStateException - If the old release parameters are periodic, the new release parameters are not periodic and the schedulable object is currently blocked in waitForNextPeriod or waitForNextPeriodInterruptible.

SecurityException - if setting of the scheduler is not allowed by the current RealtimeSystem setting.

Parameters:

scheduler - The scheduler to be used for this handler. Must not be null.

scheduling - SchedulingParameters to be associated with the handler. If null, the default value of the scheduler will be used.

release - the new release parameters. If null, the default value for the associated scheduler will be used.

memory - the new memory parameters. If null, the default value for the associated scheduler will be used.

group - the new processing group parameters to be applied for the next release of this. If null, the default value for the scheduler will be used.

setScheduler

public Schedulable setScheduler(Scheduler scheduler)
                         throws StaticIllegalArgumentException,
                                IllegalAssignmentError,
                                SecurityException

setScheduler sets the scheduler for this handler. If this has been admitted to the feasible set, it remains in the feasible set.

This change may change the feasibility of the current feasible set of this handler's scheduler.

Specified by:

setScheduler in interface Schedulable

Throws:

StaticIllegalArgumentException - iff the scheduler is null or the current parameters of this are not compatible with the new scheduler.

IllegalAssignmentError - if scheduler and this reside in memory areas whose objects cannot refer to one another (in both directions).

SecurityException - if setting of the scheduler is not allowed by the current RealtimeSystem setting.

Parameters:

scheduler - the new scheduler to be used. Must not be null.

Since:

RTSJ 2.0 returns itself

setSchedulingParameters

public Schedulable setSchedulingParameters(SchedulingParameters scheduling)
                                    throws IllegalThreadStateException

Description copied from interface: Schedulable

setSchedulingParameters sets the scheduling parameters for this Schedulable.

In JamaicaVM, this change of scheduling parameters becomes effective immediately for the default PriorityScheduler.

Specified by:

setSchedulingParameters in interface Schedulable

Throws:

IllegalThreadStateException

Parameters:

scheduling - the new scheduling parameters.

setProcessingGroupParameters

public void setProcessingGroupParameters(ProcessingGroupParameters group)

setProcessingGroupParameters sets the processing group parameters of this handler.

In JamaicaVM, this change becomes effective immediately.

This change may change the feasibility of the current feasible set of this AsyncBaseEventHandler's scheduler.

Specified by:

setProcessingGroupParameters in interface Schedulable

Throws:

StaticIllegalArgumentException - if the group argument is not compatible with the scheduler of this RealtimeThread.

Parameters:

group - the new processing group parameters to be applied for the next release of this. If null, use the default value for the scheduler.

setSchedulingParametersIfFeasible

public boolean setSchedulingParametersIfFeasible(SchedulingParameters scheduling)

setSchedulingParametersIfFeasible performs a feasibility analysis using the provided scheduling parameters. If the system remains feasible with these new parameters, the scheduling parameters are replaced.

In JamaicaVM, this change of the scheduling parameters becomes effective immediately for the default PriorityScheduler.

If this object is not a member of the feasible set of the scheduler and the resulting system is feasible, this will be added to the set.

Specified by:

setSchedulingParametersIfFeasible in interface Schedulable

Throws:

StaticIllegalArgumentException - if the parameter values are not compatible with the scheduler associated to this AsyncBaseEventHandler.

IllegalAssignmentError - if sched, release, memory or group and this reside in memory areas whose objects cannot refer to one another (in both directions).

Parameters:

scheduling - the new scheduling parameters. If null, the default value of the associated scheduler will be used. This default value may be null.

Returns:

true iff the resulting system is feasible and the new scheduling parameters have been activated. false if the resulting system is not feasible, no changes are made in this case.

finalize

protected void finalize()
                 throws Throwable

finalizer to release and terminate execution thread that is not needed any longer.

Overrides:

finalize in class Object

Throws:

Throwable - the Exception raised by this method

See Also:

WeakReference, PhantomReference

getDispatcher

public TimeDispatcher getDispatcher()

Gets the dispatcher associated with this Timable.

Specified by:

getDispatcher in interface Releasable<Timable,TimeDispatcher>

Specified by:

getDispatcher in interface Timable

Throws:

UnsupportedOperationException - always, since it is not yet implemented.

Returns:

that dispatcher.

subsumes

public boolean subsumes(Schedulable other)

Description copied from interface: Schedulable

Determine whether or not this instance of Schedulable is more eligible than other. On multicore systems, this only gives a partial ordering over all schedulables. Schedulables with disjoint processor affinity do not subsume one another.

Specified by:

subsumes in interface Schedulable

Specified by:

subsumes in interface Subsumable<Schedulable>

Parameters:

other - The object to be compared with.

Returns:

true when and only when this instance of Schedulable is more eligible than other.

run

public final void run()

Calls handleAsyncEvent repeatedly until the fire count reaches zero. The method is only to be used by the infrastructure, and should not be called by the application. The handleAsyncEvent method should be overridden instead.

The handleAsyncEvent() family of methods provides the equivalent functionality to Runnable.run() for asynchronous event handlers, including execution of the logic argument passed to this object's constructor. Applications should override the handleAsyncEvent() method instead of overwriting this method.

Specified by:

run in interface Runnable

See Also:

Thread.run()