Reading Time: 3 minutes
So, here is a glimpse of how an Akka Actor Lifecycle works. The actor lifecycle begins as soon as the actor is created.
The stages of an Akka Actor Lifecycle are as follows –
val system = ActorSystem("name_of_system") val actor = system.actorOf(Props[ActorClass])
- Creating an actor automatically starts it.
- A started actor is fully operable.
- We can start an Actor with a preStart() hook.
- And for more information, you could refer to: Creating the First Actor Guide.
context.stop(self) // to stop itself System.stop(actorRef) // actor system will stop specified actor context.stop(actorRef) // stop any other actor from current actor actorRef ! PoisonPill // get into the mailbox in the end actorRef ! Kill // get into the mailbox in the end
- An actor can stop itself and also it can stop another actor.
- A stopped actor is no longer operable.
- After the termination of the actor, we can override the postStop() hook, and now it would be available for garbage collection.
Stopping Actor with the API
- Both ActorSystem and ActorContext provide a stop method.
- Stopping an actor is an asynchronous and recursive operation:
- The actor finishes processing the current message if any
- Suspends message processing,
- Stops its children, and
- Waits for their termination confirmations and then terminates itself.
- So, stopping an actor automatically stops all its descendants.
Stopping Actor with the PoisonPill and kill
- PoisonPill and kill are specially handled messages that get enqueued into the actor’s mailbox and cause the actor to stop when they’re handled.
- When an Actor handles a PoisonPill message it simply calls context.stop(self()).
- When an actor handles a kill message it throws an ActorKilledException.
- Both allow an actor to finish handling all messages placed in their mailbox before the PoisonPill or Kill.
- Moreover, these behaviors can’t be overridden by handling the messages yourself, not appropriate when the Actor needs to perform cleanup before shutting down.
Elegant way to stop an actor
- If an actor needs to perform certain tasks before stopping it
- then it should advertise a dedicated message for that purpose,
- handle it as appropriate and stop it after that and stop it after that.
- And for more information you could refer to Akka Actors Stopping Guide.
context.watch(actorRef) Termination(value) // to keep a track that which actor died
- An actor can monitor another actor’s termination, aka deathwatch
- An actor could watch another actor and get notified of its termination.
- Keep it in mind that an actor could not keep a watch on its own death.
- On termination, the monitoring actor is sent a Terminated message
- We have to handle Termination(value) to keep track that exactly which actor died? In case the actor is watching so many actors.
- DeathPactException occurs when we do not handle a termination.
- And for more information, you could also refer to DeadWatch API.
- Within an actor system, actors are arranged in a hierarchy.
- Therefore each actor has a parent.
- Each actor has a name which is unique amongst its siblings.
- The identification of an actor is through its unique sequence of names.
- An ActorPath encapsulates a sequence of actor names with transport protocol and address of the actor system.
- To obtain an actor path call path on ActorRef.
- To get an actor’s name call name on ActorPath.
- And for more information, you could also refer to Actor References, Paths, and Addresses Guide.
You can explore more about Akka Lifecycle here.