NonBlockingFiniteStateMachine (Oracle® Coherence Java API Reference)

java.lang.Object
- com.tangosol.util.fsm.NonBlockingFiniteStateMachine<S>

All Implemented Interfaces:

ExecutionContext, FiniteStateMachine<S>
```
public class NonBlockingFiniteStateMachine<S extends Enum<S>>
extends Object
implements FiniteStateMachine<S>, ExecutionContext
```
An NonBlockingFiniteStateMachine is a specialized FiniteStateMachine implementation that performs transitions asynchronously to the threads that request state changes. That is, threads that request state transitions are never blocked. Instead their requests are queued for a single thread to later perform the appropriate transition to the requested state.

Since:

Coherence 12.2.1

Author:

Brian Oliver

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`NonBlockingFiniteStateMachine.CoalescedEvent<S extends Enum<S>>` A `NonBlockingFiniteStateMachine.CoalescedEvent` is a `LifecycleAwareEvent` that coalesces other (wrapped) `Event`s with the same discriminator so that only one `Event` actually executes.
`static class`	`NonBlockingFiniteStateMachine.DefaultTaskDependencies` Implementation of Dependencies for Task
`static class`	`NonBlockingFiniteStateMachine.DelayedTransitionTo<S extends Enum<S>>` A `NonBlockingFiniteStateMachine.DelayedTransitionTo` is a specialized `Instruction` for `NonBlockingFiniteStateMachine`s that enables a `StateEntryAction` to request a delayed transition to another state, unlike a `Instruction.TransitionTo` `Instruction` which occurs immediately.
`static class`	`NonBlockingFiniteStateMachine.ProcessEventLater<S extends Enum<S>>` A specialized `Instruction` for `NonBlockingFiniteStateMachine`s that enables a `StateEntryAction` to request an `Event` to be processed at some point in the future.
`static class`	`NonBlockingFiniteStateMachine.SubsequentEvent<S extends Enum<S>>` A `NonBlockingFiniteStateMachine.SubsequentEvent` is an `Event` that ensures that another (wrapped) `Event` to occur if an only if the `FiniteStateMachine` is at a certain transition count.
`protected class`	`NonBlockingFiniteStateMachine.Task` A PriorityTask implementation to process a requested event.
`static interface`	`NonBlockingFiniteStateMachine.TaskDependencies` Dependencies for Task.

Constructor Summary

Constructors
Constructor and Description
`NonBlockingFiniteStateMachine(String sName, Model<S> model, S stateInitial, com.tangosol.internal.util.DaemonPoolDependencies daemonPoolDeps, boolean fIgnoreExceptions, NonBlockingFiniteStateMachine.TaskDependencies deps)` Construct an `NonBlockingFiniteStateMachine` given a `Model`.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addListener(FiniteStateMachineListener<S> listener)` Add a `FiniteStateMachineListener` to the `FiniteStateMachine`.
`String`	`getName()` Obtains the name of the `FiniteStateMachine`.
`S`	`getState()` Obtains the current state of the `FiniteStateMachine`.
`long`	`getTransitionCount()` Obtains the number of transitions that have occurred in the `FiniteStateMachine`.
`boolean`	`hasPendingEvents()` Determines if there are any pending `Event`s for the `FiniteStateMachine` to process.
`void`	`process(Event<S> event)` Request the `FiniteStateMachine` to process the specified `Event`.
`void`	`processLater(Event<S> event)` Request the `FiniteStateMachine` to process the specified `Event` as soon as possible.
`void`	`processLater(Event<S> event, long duration, TimeUnit timeUnit)` Request the `FiniteStateMachine` to process the specified `Event` at some point in the future (represented as a duration to wait from the moment the method is called).
`boolean`	`quiesceThenStop()` Requests the `FiniteStateMachine` to stop accepting new `Event`s to process, wait for any existing queued `Event`s to be processed and then stop.
`void`	`removeListener(FiniteStateMachineListener<S> listener)` Remove a `FiniteStateMachineListener` from the `FiniteStateMachine`.
`boolean`	`start()` Start the `FiniteStateMachine` and enter the initial state.
`boolean`	`stop()` Stops the `FiniteStateMachine` as soon as possible.
`String`	`toString()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - NonBlockingFiniteStateMachine
```
public NonBlockingFiniteStateMachine(String sName,
                                     Model<S> model,
                                     S stateInitial,
                                     com.tangosol.internal.util.DaemonPoolDependencies daemonPoolDeps,
                                     boolean fIgnoreExceptions,
                                     NonBlockingFiniteStateMachine.TaskDependencies deps)
```
    Construct an NonBlockingFiniteStateMachine given a Model.
    
    Parameters:
    
    sName - the name of the NonBlockingFiniteStateMachine
    
    model - the Model of the NonBlockingFiniteStateMachine
    
    stateInitial - the initial state
    
    daemonPoolDeps - Optional DaemonPoolDependencies for Daemon Pool that will be used for scheduling Transitions
    
    fIgnoreExceptions - when true RuntimeExceptions will be ignored, when false RuntimeExceptions will immediately stop the NonBlockingFiniteStateMachine
    
    deps - the NonBlockingFiniteStateMachine.TaskDependencies specifies the event processing configs.
- Method Detail
  - addListener
```
public void addListener(FiniteStateMachineListener<S> listener)
```
    Add a FiniteStateMachineListener to the FiniteStateMachine.
    Note that unique instances of FiniteStateMachineListener are identified via their #equals and #hashCode implementations.
    
    Specified by:
    
    addListener in interface FiniteStateMachine<S extends Enum<S>>
    
    Parameters:
    
    listener - the listener to be added
  - removeListener
```
public void removeListener(FiniteStateMachineListener<S> listener)
```
    Remove a FiniteStateMachineListener from the FiniteStateMachine.
    Note that unique instances of FiniteStateMachineListener are identified via their #equals and #hashCode implementations.
    
    Specified by:
    
    removeListener in interface FiniteStateMachine<S extends Enum<S>>
    
    Parameters:
    
    listener - the listener to be removed
  - getName
```
public String getName()
```
    Obtains the name of the FiniteStateMachine. This is primarily used for display/logging/monitoring purposes.
    
    Specified by:
    
    getName in interface ExecutionContext
    
    Specified by:
    
    getName in interface FiniteStateMachine<S extends Enum<S>>
    
    Returns:
    
    the name of the FiniteStateMachine
  - getState
```
public S getState()
```
    Obtains the current state of the FiniteStateMachine.
    Note: After returning the current state there's no guarantee that the state will be the same because a Transition may be executing asynchronously in the background on another thread.
    
    Specified by:
    
    getState in interface FiniteStateMachine<S extends Enum<S>>
    
    Returns:
    
    the current state of the FiniteStateMachine
  - getTransitionCount
```
public long getTransitionCount()
```
    Obtains the number of transitions that have occurred in the FiniteStateMachine.
    Note: After returning the count there's no guarantee that the count will be the same on the next request because a Transition may be executing asynchronously in the background on another thread.
    
    Specified by:
    
    getTransitionCount in interface ExecutionContext
    
    Specified by:
    
    getTransitionCount in interface FiniteStateMachine<S extends Enum<S>>
    
    Returns:
    
    the number of transitions that have occurred in the FiniteStateMachine
  - start
```
public boolean start()
```
    Start the FiniteStateMachine and enter the initial state.
    Note: Once stopped a FiniteStateMachine can't be restarted; instead a new FiniteStateMachine should be created.
    
    Specified by:
    
    start in interface FiniteStateMachine<S extends Enum<S>>
    
    Returns:
    
    true if the start was successful or the FiniteStateMachine is already stated, false if it has been stopped
  - stop
```
public boolean stop()
```
    Stops the FiniteStateMachine as soon as possible.
    Note: Once stopped a FiniteStateMachine can't be restarted; instead a new FiniteStateMachine should be created.
    
    Specified by:
    
    stop in interface FiniteStateMachine<S extends Enum<S>>
    
    Returns:
    
    true if the stop was successful, false if it's already stopped
  - quiesceThenStop
```
public boolean quiesceThenStop()
```
    Requests the FiniteStateMachine to stop accepting new Events to process, wait for any existing queued Events to be processed and then stop.
    Note: Once stopped a FiniteStateMachine can't be restarted. Instead a new FiniteStateMachine should be created.
    
    Returns:
    
    true if the FiniteStateMachine was stopped or false if it was already stopped
    
    Throws:
    
    IllegalStateException - if the FiniteStateMachine was never started
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - process
```
public void process(Event<S> event)
```
    Request the FiniteStateMachine to process the specified Event.
    Note: There's no guarantee that the Event will be processed because:
    1. the Transition to be performed for the Event is invalid as the FiniteStateMachine is not in the required starting state.
    2. the FiniteStateMachine may have been stopped.
    Specified by:
    
    process in interface FiniteStateMachine<S extends Enum<S>>
    
    Parameters:
    
    event - the Event for the FiniteStateMachine to process
  - processLater
```
public void processLater(Event<S> event)
```
    Request the FiniteStateMachine to process the specified Event as soon as possible.
    Note: This method is semantically equivalent to process(Event).
    
    Parameters:
    
    event - the Event for the FiniteStateMachine to process
  - processLater
```
public void processLater(Event<S> event,
                         long duration,
                         TimeUnit timeUnit)
```
    Request the FiniteStateMachine to process the specified Event at some point in the future (represented as a duration to wait from the moment the method is called).
    Note: There's no guarantee that the Event will processed because:
    1. the Transition to be performed for the Event is invalid as the FiniteStateMachine is not in the required starting state.
    2. the FiniteStateMachine may have been stopped.
    Parameters:
    
    event - the Event for the FiniteStateMachine to process
    
    duration - the amount of the TimeUnit to wait before the Event is processed
    
    timeUnit - the TimeUnit
  - hasPendingEvents
```
public boolean hasPendingEvents()
```
    Determines if there are any pending Events for the FiniteStateMachine to process.
    Note: If the FiniteStateMachine can no longer process Events false will be returned.
    
    Returns:
    
    true if there are pending Events and Events can be processed, false otherwise

Class NonBlockingFiniteStateMachine<S extends Enum<S>>

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

NonBlockingFiniteStateMachine

Method Detail

addListener

removeListener

getName

getState

getTransitionCount

start

stop

quiesceThenStop

toString

process

processLater

processLater

hasPendingEvents