Why creating an actor within actor is dangerous

Question

The akka documentation is clearly stated that it is dangerous to create an actor within an actor like this:

class ActorA extends Actor {
  def receive = ???
}

final class ActorB extends Actor {
  def receive = {
  case _ =>
  val act = context.actorOf(Props(new ActorA))
}}

I understand that the Actor's apply method is accepting this reference of the creating actor. yet I couldn't understand (nor couldn't find any example) why this is harmful and what issues it can cause?

Answer 1

Let's tweak your example a little bit

class ActorA(str:String) extends Actor {
  def receive = ???
}

final class ActorB extends Actor {
  def receive = {
  case _ =>
  val act = context.actorOf(Props(new ActorA("hidden")))
}}

Most of the common use case of using actors are to handle failover and supervision, shen an actor fails and needs to be restarted, the actor system needs to know how to do that. When you use Props(Props(new ActorA)), you've hidden the parameter value of "hidden" by handling it yourself.

Rather than doing that if instead, you declare how to create instances of the actor, the actor system will know exactly what it needs to do when recreating an actor - i.e. create an instance of ActorA with a constructor argument of "hidden".

Even with your example of Actor without param

context.actorOf(Props(new ActorA))

this way of instantiating actors within another actor is not recommended because it encourages to close over the enclosing scope, resulting in non-serializable Props and possibly race conditions (breaking the actor encapsulation).