The DefaultActor class is the base for all stateful actors, who need to maintain implicit state between subsequent message arrivals. Allowing the actor creator to structure code in a continuation-like style with message retrieval react commands mixed within normal code makes implementation of some algorithms particularly easy.
The DefaultActor upon start-up will grab a thread from the associated actor thread pool and run its body. The body is either the parameter passed to the constructor, or the act() method, if no parameter has been set. The parameter takes precedence over the act() method. Once a react() method call is discovered within the actor's body, its Closure-typed parameter will be scheduled for processing on next message arrival. To preserve the actor principle of at-most-one active thread per actor, the next message, however, will only be handled once the currently run code finishes and frees the current thread. It is thus advisable to avoid code after call to react(). The loop() method will ensure its body is executed repeatedly, until the actor either finishes or an optional loop condition is not met.
| Modifiers | Name | Description |
|---|---|---|
private static java.lang.String |
EXPECTED |
|
private groovy.lang.Closure |
afterLoopCode |
|
private groovy.lang.Closure |
loopClosure |
|
private java.lang.Runnable |
loopCode |
Misused also for the code to run at start-up |
private java.util.concurrent.Callable<java.lang.Boolean> |
loopCondition |
|
private groovy.lang.Closure |
nextContinuation |
|
private static long |
serialVersionUID |
|
private boolean |
started |
| Fields inherited from class | Fields |
|---|---|
class AbstractLoopingActor |
core, currentSender, currentTimerTask, serialVersionUID, stoppedFlag, terminatedFlag, terminatingFlag, timeoutCounter |
class Actor |
ACTOR_HAS_ALREADY_BEEN_STARTED, AFTER_START, CANNOT_SEND_REPLIES_NO_SENDER_HAS_BEEN_REGISTERED, EMPTY_ARGUMENTS, ON_DELIVERY_ERROR, RESPONDS_TO, START_MESSAGE, STOP_MESSAGE, TERMINATE_MESSAGE, TIMEOUT, TIMEOUT_MESSAGE, currentActorPerThread, currentThread, joinLatch, onStop, parallelGroup, serialVersionUID, timer |
class MessageStream |
serialVersionUID |
class WithSerialId |
serialHandle, serialVersionUID |
| Constructor and description |
|---|
DefaultActor
()Creates an actor, which will execute its act() methods |
DefaultActor
(java.lang.Runnable code)Creates an actor, which will execute the supplied code |
| Type | Name and description |
|---|---|
protected void |
act()If no parameter is provided at construction time, the act() method becomes the actor's body |
private static void |
checkForBodyArguments(groovy.lang.Closure closure) |
private static void |
checkForMessageHandlerArguments(groovy.lang.Closure code) |
private static void |
checkForNull(java.lang.Runnable code) |
private void |
doLoop(java.util.concurrent.Callable<java.lang.Boolean> condition, groovy.lang.Closure afterLoopCode, java.lang.Runnable code)Ensures that the supplied closure will be invoked repeatedly in a loop. |
private groovy.lang.Closure |
enhanceClosure(groovy.lang.Closure closure) |
private boolean |
evalLoopCondition() |
protected void |
handleStart()Called once the START_MESSAGE arrives. |
void |
loop(java.lang.Runnable code)Ensures that the supplied closure will be invoked repeatedly in a loop. |
protected void |
loop(int numberOfLoops, java.lang.Runnable code)Ensures that the supplied closure will be invoked repeatedly in a loop. |
protected void |
loop(int numberOfLoops, groovy.lang.Closure afterLoopCode, java.lang.Runnable code)Ensures that the supplied closure will be invoked repeatedly in a loop. |
protected void |
loop(groovy.lang.Closure condition, java.lang.Runnable code)Ensures that the supplied closure will be invoked repeatedly in a loop. |
protected void |
loop(groovy.lang.Closure condition, groovy.lang.Closure afterLoopCode, java.lang.Runnable code)Ensures that the supplied closure will be invoked repeatedly in a loop. |
void |
onMessage(java.lang.Object message)Handles all incoming messages |
void |
react(groovy.lang.Closure code)Schedules an ActorAction to take the next message off the message queue and to pass it on to the supplied closure. |
protected void |
react(groovy.time.Duration duration, groovy.lang.Closure code)Schedules an ActorAction to take the next message off the message queue and to pass it on to the supplied closure. |
protected void |
react(long timeout, java.util.concurrent.TimeUnit timeUnit, groovy.lang.Closure code)Schedules an ActorAction to take the next message off the message queue and to pass it on to the supplied closure. |
protected void |
react(long timeout, groovy.lang.Closure code)Schedules an ActorAction to take the next message off the message queue and to pass it on to the supplied closure. |
private void |
runAfterLoopCode(groovy.lang.Closure afterLoopCode) |
Actor |
silentStart()Not supported by DefaultActor |
Actor |
start()Starts the Actor and sends it the START_MESSAGE to run any afterStart handlers. |
Misused also for the code to run at start-up
Creates an actor, which will execute its act() methods
Creates an actor, which will execute the supplied code
code - A Runnable or Closure to be considered the actor's bodyIf no parameter is provided at construction time, the act() method becomes the actor's body
Ensures that the supplied closure will be invoked repeatedly in a loop. The method never returns, but instead frees the processing thread back to the thread pool.
condition - A condition to evaluate before each iteration starts. If the condition returns false, the loop exits.afterLoopCode - Code to run after the main actor's loop finishescode - The closure to invoke repeatedlyCalled once the START_MESSAGE arrives. We need to run the actor's body here, letting it set nextContinuation to hols the next message handler
Ensures that the supplied closure will be invoked repeatedly in a loop. The method never returns, but instead frees the processing thread back to the thread pool.
code - The closure to invoke repeatedlyEnsures that the supplied closure will be invoked repeatedly in a loop. The method never returns, but instead frees the processing thread back to the thread pool.
numberOfLoops - The loop will only be run the given number of timescode - The closure to invoke repeatedlyEnsures that the supplied closure will be invoked repeatedly in a loop. The method never returns, but instead frees the processing thread back to the thread pool.
numberOfLoops - The loop will only be run the given number of timesafterLoopCode - Code to run after the main actor's loop finishescode - The closure to invoke repeatedlyEnsures that the supplied closure will be invoked repeatedly in a loop. The method never returns, but instead frees the processing thread back to the thread pool.
condition - A condition to evaluate before each iteration starts. If the condition returns false, the loop exits.code - The closure to invoke repeatedlyEnsures that the supplied closure will be invoked repeatedly in a loop. The method never returns, but instead frees the processing thread back to the thread pool.
condition - A condition to evaluate before each iteration starts. If the condition returns false, the loop exits.afterLoopCode - Code to run after the main actor's loop finishescode - The closure to invoke repeatedlyHandles all incoming messages
message - The current message to processSchedules an ActorAction to take the next message off the message queue and to pass it on to the supplied closure. The method never returns, but instead frees the processing thread back to the thread pool.
code - The code to handle the next message. The reply() and replyIfExists() methods are available inside
the closure to send a reply back to the actor, which sent the original message.Schedules an ActorAction to take the next message off the message queue and to pass it on to the supplied closure. The method never returns, but instead frees the processing thread back to the thread pool.
duration - Time to wait at most for a message to arrive. The actor terminates if a message doesn't arrive within the given timeout.
The TimeCategory DSL to specify timeouts must be enabled explicitly inside the Actor's act() method.code - The code to handle the next message. The reply() and replyIfExists() methods are available inside
the closure to send a reply back to the actor, which sent the original message.Schedules an ActorAction to take the next message off the message queue and to pass it on to the supplied closure. The method never returns, but instead frees the processing thread back to the thread pool.
timeout - Time in milliseconds to wait at most for a message to arrive. The actor terminates if a message doesn't arrive within the given timeout.timeUnit - a TimeUnit determining how to interpret the timeout parametercode - The code to handle the next message. The reply() and replyIfExists() methods are available inside
the closure to send a reply back to the actor, which sent the original message.Schedules an ActorAction to take the next message off the message queue and to pass it on to the supplied closure. The method never returns, but instead frees the processing thread back to the thread pool. Also adds reply() and replyIfExists() methods to the currentActor and the message. These methods will call send() on the target actor (the sender of the original message). The reply()/replyIfExists() methods invoked on the actor will be sent to all currently processed messages, reply()/replyIfExists() invoked on a message will send a reply to the sender of that particular message only.
timeout - Time in milliseconds to wait at most for a message to arrive. The actor terminates if a message doesn't arrive within the given timeout.code - The code to handle the next message. The reply() and replyIfExists() methods are available inside
the closure to send a reply back to the actor, which sent the original message.Not supported by DefaultActor
Starts the Actor and sends it the START_MESSAGE to run any afterStart handlers. No messages can be sent or received before an Actor is started.
Copyright © 2008–2014 Václav Pech. All Rights Reserved.