javax.realtime
Class AbstractAsyncEventHandler

java.lang.Object
  javax.realtime.AbstractAsyncEventHandler

All Implemented Interfaces:

Runnable, Schedulable

Direct Known Subclasses:

AsyncEventHandler

public abstract class AbstractAsyncEventHandler
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 BoundAbstractAsyncEventHandler may be used, these handlers are bound to their own RealtimeThread for execution, but they require more system resources (threads and memory).

Ab AbstractAsyncEventHandlers may make use of memory areas exactly as a RealtimeThread does.

Since:

RTSJ V1.1

Method Summary

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.
void	finalize() finalizer to release and terminate execution thread that is not needed any longer.
protected int	getAndClearPendingFireCount() getAndClearPendingFireCount sets the pending fire count to zero and returns the original value.
protected int	getAndDecrementPendingFireCount() getAndDecrementPendingFireCount decrements the pending fire count and returns the original value.
protected int	getAndIncrementPendingFireCount() Increments the pending fire count and returns the original value.
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 AbstractAsyncEventHandler.
protected int	getPendingFireCount() getPendingFireCount returns the current number of pending invocations to handleAsyncEvent().
ProcessingGroupParameters	getProcessingGroupParameters() getProcessingGroupParameters returns the current ProcessingGroupParameters of this AbstractAsyncEventHandler.
ReleaseParameters	getReleaseParameters() getReleaseParameters returns the current ReleaseParameters of this AbstractAsyncEventHandler.
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	removeFromFeasibility() removeFromFeasibility informs the scheduler associated with this AbstractAsyncEventHandler that this AbstractAsyncEventHandler should no longer be taken into account in the feasibility analysis.
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.
void	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.
void	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.
void	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.
void	setSchedulingParameters(SchedulingParameters scheduling) setSchedulingParameters sets the scheduling parameters for this handler.
boolean	setSchedulingParametersIfFeasible(SchedulingParameters scheduling) setSchedulingParametersIfFeasible performs a feasibility analysis using the provided scheduling parameters.

Methods inherited from class java.lang.Object

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

Methods inherited from interface java.lang.Runnable

run

Method Detail

getPendingFireCount

protected int getPendingFireCount()

getPendingFireCount returns the current number of pending invocations to handleAsyncEvent(). During the execution of handleAsyncEvent(), the fireCount 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()

getAndClearPendingFireCount sets the pending fire count to zero and returns the original value.

Returns:

the original fire count.

getAndDecrementPendingFireCount

protected int getAndDecrementPendingFireCount()

getAndDecrementPendingFireCount decrements the pending fire count and returns the original value.

Returns:

the original fire count.

getAndIncrementPendingFireCount

protected int getAndIncrementPendingFireCount()

Increments the pending fire count and returns the original value. Incrementing may result in a violation of the minimum interarrival time or in an overflow of the arrival time queue. In this case, the fire count will not be incremented.

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).

Returns:

true iff this is a daemon handler.

Since:

RTSJ V1.0.1

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).

Parameters:

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

Throws:

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

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

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 IllegalArgumentException,
                             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

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.

Throws:

IllegalArgumentException - if the parameter values are not compatible with the scheduler associated to this AbstractAsyncEventHandler.

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.

setIfFeasible

public boolean setIfFeasible(SchedulingParameters sched,
                             ReleaseParameters release,
                             MemoryParameters memory)
                      throws IllegalArgumentException,
                             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

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.

Throws:

IllegalArgumentException - if the parameter values are not compatible with the scheduler associated to this AbstractAsyncEventHandler.

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.

Since:

RTSJ V1.0.1

setIfFeasible

public boolean setIfFeasible(ReleaseParameters release,
                             MemoryParameters memory,
                             ProcessingGroupParameters group)
                      throws IllegalArgumentException,
                             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

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.

Throws:

IllegalArgumentException - if the parameter values are not compatible with the scheduler associated to this AbstractAsyncEventHandler.

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.

setIfFeasible

public boolean setIfFeasible(SchedulingParameters sched,
                             ReleaseParameters release,
                             MemoryParameters memory,
                             ProcessingGroupParameters group)
                      throws IllegalArgumentException,
                             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

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.

Throws:

IllegalArgumentException - if the parameter values are not compatible with the scheduler associated to this AbstractAsyncEventHandler.

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.

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

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.

Throws:

IllegalArgumentException - if the parameter values are not compatible with the scheduler associated to this AbstractAsyncEventHandler.

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.

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

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.

Throws:

IllegalArgumentException - if the group parameter value is not compatible with the scheduler associated to this AbstractAsyncEventHandler.

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

setIfFeasible

public boolean setIfFeasible(ReleaseParameters release,
                             ProcessingGroupParameters group)
                      throws IllegalArgumentException,
                             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

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.

Throws:

IllegalArgumentException - if the parameter values are not compatible with the scheduler associated to this AbstractAsyncEventHandler.

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.

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

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.

Throws:

IllegalArgumentException - if the memory parameter value is not compatible with the scheduler associated to this AbstractAsyncEventHandler.

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

getMemoryParameters

public MemoryParameters getMemoryParameters()

getMemoryParameters returns a reference to the MemoryParameters of this AbstractAsyncEventHandler.

Specified by:

getMemoryParameters in interface Schedulable

Returns:

the MemoryParameters of this AbstractAsyncEventHandler.

getReleaseParameters

public ReleaseParameters getReleaseParameters()

getReleaseParameters returns the current ReleaseParameters of this AbstractAsyncEventHandler.

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 AbstractAsyncEventHandler.

Specified by:

getProcessingGroupParameters in interface Schedulable

Returns:

the ProcessingGroupParameters

removeFromFeasibility

public boolean removeFromFeasibility()

removeFromFeasibility informs the scheduler associated with this AbstractAsyncEventHandler that this AbstractAsyncEventHandler 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 void 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

Parameters:

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

Throws:

IllegalArgumentException - if the memory parameter value is not compatible with the scheduler associated to this AbstractAsyncEventHandler.

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

IllegalThreadStateException

setReleaseParameters

public void 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

Parameters:

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

Throws:

IllegalArgumentException - if the release parameter value is not compatible with the scheduler associated to this AbstractAsyncEventHandler.

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.

setScheduler

public void setScheduler(Scheduler scheduler,
                         SchedulingParameters scheduling,
                         ReleaseParameters release,
                         MemoryParameters memory,
                         ProcessingGroupParameters group)
                  throws IllegalArgumentException,
                         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

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.

Throws:

IllegalArgumentException - 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.

setScheduler

public void setScheduler(Scheduler scheduler)
                  throws IllegalArgumentException,
                         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

Parameters:

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

Throws:

IllegalArgumentException - 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.

setSchedulingParameters

public void setSchedulingParameters(SchedulingParameters scheduling)
                             throws IllegalThreadStateException

setSchedulingParameters sets the scheduling parameters for this handler.

In JamaicaVM, this change of the scheduling parameters becomes effective at the next release for the default PriorityScheduler.

Specified by:

setSchedulingParameters in interface Schedulable

Parameters:

scheduling - the new scheduling parameters.

Throws:

IllegalArgumentException - iff scheduling is not compatible with the scheduler.

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

IllegalThreadStateException

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 AbstractAsyncEventHandler's scheduler.

Specified by:

setProcessingGroupParameters in interface Schedulable

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.

Throws:

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

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

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.

Throws:

IllegalArgumentException - if the parameter values are not compatible with the scheduler associated to this AbstractAsyncEventHandler.

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

finalize

public void finalize()

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

Overrides:

finalize in class Object