Understanding Akka Actor Lifecycle

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 –

• preStart()
• Start
• Stop
• postStop()
• terminated

Starting Actors

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.

Stopping Actor

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.

Death Watch

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.

Actor Path

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