In the previous chapter, you learned about some basic and advanced things about Akka actors. In this chapter, you will learn about supervision and monitoring of Akka actors.

Using supervision and monitoring, we can write fault-tolerant systems, which can run continuously for days, months, and years without stopping. Let's see what is meant by fault tolerance.

Fault tolerance is a property of systems that are intended to be always responsive rather than failing completely in case of a failure. Such systems are known as fault tolerance systems or resilient systems.

In simple words, a fault-tolerant system is one which is destined to continue as more or less fully operational, with perhaps a reduction in throughput or an increase...

In this recipe, we will learn how to create child actors of an actor. Akka follows a tree-like hierarchy to create actors and it is also the recommended practice.

By following such practices, we can handle failures in actors as the parent can take care of it. Lets see how to do it.

We need to import the Hello-Akka project in the IDE of our choice. The Akka actor dependency that we added in build.sbt is sufficient for most of the recipes in this chapter, so we will skip the Getting ready section in our further recipes.

1. Create a file named ParentChild...

Since we are talking about supervision and monitoring of actors, you should understand the life cycle hooks of an actor. In this recipe, you will learn how to override the life cycle hooks of an actor when it starts, stops, prestarts, and postrestarts.

1. Create a file called ActorLifeCycle.scala in package com.packt.chapter2.
2. Add the following imports to the top of the file:

        import akka.actor._ 
        import akka.actor.SupervisorStrategy._ 
        import akka.util.Timeout 
        import scala.concurrent.Await 
        import scala.concurrent.duration._ 
        import akka.pattern.ask 

3. Create the following messages to be sent to the actors:

        case object Error  
        case class StopActor...

In this recipe, you will learn how a parent sends messages to its child, and collects responses from them.

To step through this recipe, we need to import the Hello-Akka project in the IDE.

1. Create a file, SendMesagesToChilds.scala, in package com.packt.chapter2.
2. Add the following imports to the top of the file:

        import akka.actor.{ Props, ActorSystem, Actor, ActorRef } 

3. Create messages to be sent to the actors as follows:

        case class DoubleValue(x: Int) 
        case object CreateChild 
        case object Send 
        case class Response(x: Int) 

4. Define a child actor. It doubles the value sent to it.

        class DoubleActor extends Actor { 
          def receive = { 
        ...

In this recipe, you will learn about OneForOneStrategy to implement the let it crash model.

The OneForOneStrategy class is applied when we want to supervise the child actors in such a way that only the failed child would be restarted, resumed, or escalated, not it's siblings. If we don't specify any supervisor strategy, then the default would be OneForOneStrategy. Let's understand it.

The OneForOneStrategy class is useful when actors are not dependent on each other, they are each responsible for a single task, and failure of one actor does not affect another.

To step through this recipe, we need to import the Hello-Akka project in IDE.

1. Create a file, SupervisorStrategy.scala, in...