trait Actor extends AnyRef
Actor base trait that should be extended by or mixed to create an Actor with the semantics of the 'Actor Model': http://en.wikipedia.org/wiki/Actor_model
An actor has a well-defined (non-cyclic) life-cycle.
- RUNNING (created and started actor) - can receive messages
- SHUTDOWN (when 'stop' is invoked) - can't do anything
The Actor's own akka.actor.ActorRef is available as self, the current
message’s sender as sender() and the akka.actor.ActorContext as
context. The only abstract method is receive which shall return the
initial behavior of the actor as a partial function (behavior can be changed
using context.become and context.unbecome).
This is the Scala API (hence the Scala code below), for the Java API see akka.actor.UntypedActor.
class ExampleActor extends Actor { override val supervisorStrategy = OneForOneStrategy(maxNrOfRetries = 10, withinTimeRange = 1 minute) { case _: ArithmeticException => Resume case _: NullPointerException => Restart case _: IllegalArgumentException => Stop case _: Exception => Escalate } def receive = { // directly calculated reply case Request(r) => sender() ! calculate(r) // just to demonstrate how to stop yourself case Shutdown => context.stop(self) // error kernel with child replying directly to 'sender()' case Dangerous(r) => context.actorOf(Props[ReplyToOriginWorker]).tell(PerformWork(r), sender()) // error kernel with reply going through us case OtherJob(r) => context.actorOf(Props[ReplyToMeWorker]) ! JobRequest(r, sender()) case JobReply(result, orig_s) => orig_s ! result } }
The last line demonstrates the essence of the error kernel design: spawn
one-off actors which terminate after doing their job, pass on sender() to
allow direct reply if that is what makes sense, or round-trip the sender
as shown with the fictitious JobRequest/JobReply message pair.
If you don’t like writing context you can always import context._ to get
direct access to actorOf, stop etc. This is not default in order to keep
the name-space clean.
- Source
- Actor.scala
- Alphabetic
- By Inheritance
- Actor
- AnyRef
- Any
- by any2stringadd
- by StringFormat
- by Ensuring
- by ArrowAssoc
- Hide All
- Show All
- Public
- All
Type Members
- type Receive = PartialFunction[Any, Unit]
Abstract Value Members
-
abstract
def
receive: Actor.Receive
This defines the initial actor behavior, it must return a partial function with the actor logic.
Concrete Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
- def +(other: String): String
- def ->[B](y: B): (Actor, B)
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
aroundPostRestart(reason: Throwable): Unit
Can be overridden to intercept calls to
postRestart.Can be overridden to intercept calls to
postRestart. CallspostRestartby default.- Attributes
- protected[akka]
-
def
aroundPostStop(): Unit
Can be overridden to intercept calls to
postStop.Can be overridden to intercept calls to
postStop. CallspostStopby default.- Attributes
- protected[akka]
-
def
aroundPreRestart(reason: Throwable, message: Option[Any]): Unit
Can be overridden to intercept calls to
preRestart.Can be overridden to intercept calls to
preRestart. CallspreRestartby default.- Attributes
- protected[akka]
-
def
aroundPreStart(): Unit
Can be overridden to intercept calls to
preStart.Can be overridden to intercept calls to
preStart. CallspreStartby default.- Attributes
- protected[akka]
-
def
aroundReceive(receive: Actor.Receive, msg: Any): Unit
INTERNAL API.
INTERNAL API.
Can be overridden to intercept calls to this actor's current behavior.
- receive
current behavior.
- msg
current message.
- Attributes
- protected[akka]
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
implicit
val
context: ActorContext
Stores the context for this actor, including self, and sender.
Stores the context for this actor, including self, and sender. It is implicit to support operations such as
forward.WARNING: Only valid within the Actor itself, so do not close over it and publish it to other threads!
akka.actor.ActorContext is the Scala API.
getContextreturns a akka.actor.UntypedActorContext, which is the Java API of the actor context. - def ensuring(cond: (Actor) ⇒ Boolean, msg: ⇒ Any): Actor
- def ensuring(cond: (Actor) ⇒ Boolean): Actor
- def ensuring(cond: Boolean, msg: ⇒ Any): Actor
- def ensuring(cond: Boolean): Actor
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
finalize(): Unit
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
- def formatted(fmtstr: String): String
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
-
def
postRestart(reason: Throwable): Unit
User overridable callback: By default it calls
preStart().User overridable callback: By default it calls
preStart().- reason
the Throwable that caused the restart to happen Is called right AFTER restart on the newly created Actor to allow reinitialization after an Actor crash.
- Annotations
- @throws( classOf[Exception] )
-
def
postStop(): Unit
User overridable callback.
User overridable callback.
Is called asynchronously after 'actor.stop()' is invoked. Empty default implementation.
- Annotations
- @throws( classOf[Exception] )
-
def
preRestart(reason: Throwable, message: Option[Any]): Unit
User overridable callback: By default it disposes of all children and then calls
postStop().User overridable callback: By default it disposes of all children and then calls
postStop().- reason
the Throwable that caused the restart to happen
- message
optionally the current message the actor processed when failing, if applicable Is called on a crashed Actor right BEFORE it is restarted to allow clean up of resources before Actor is terminated.
- Annotations
- @throws( classOf[Exception] )
-
def
preStart(): Unit
User overridable callback.
User overridable callback.
Is called when an Actor is started. Actors are automatically started asynchronously when created. Empty default implementation.
- Annotations
- @throws( classOf[Exception] )
-
implicit final
val
self: ActorRef
The 'self' field holds the ActorRef for this actor.
The 'self' field holds the ActorRef for this actor.
Can be used to send messages to itself:
self ! message
-
final
def
sender(): ActorRef
The reference sender Actor of the last received message.
The reference sender Actor of the last received message. Is defined if the message was sent from another Actor, else
deadLettersin akka.actor.ActorSystem.WARNING: Only valid within the Actor itself, so do not close over it and publish it to other threads!
-
def
supervisorStrategy: SupervisorStrategy
User overridable definition the strategy to use for supervising child actors.
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
def
unhandled(message: Any): Unit
User overridable callback.
User overridable callback.
Is called when a message isn't handled by the current behavior of the actor by default it fails with either a akka.actor.DeathPactException (in case of an unhandled akka.actor.Terminated message) or publishes an akka.actor.UnhandledMessage to the actor's system's akka.event.EventStream
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
- def →[B](y: B): (Actor, B)