Diseño de sistemas de actores

¡Bienvenido a la lección 2! En la lección anterior aprendimos los conceptos básicos del modelo de actores de Akka. Ahora profundizaremos en el diseño de sistemas de actores de Akka.

Un sistema de actores bien diseñado es robusto, escalable y fácil de mantener. Exploraremos cómo estructurar los actores, definir sus comportamientos y permitir que se comuniquen eficazmente.

Los actores de Akka se organizan en una jerarquía con forma de árbol, como un sistema de archivos. Todos los actores, excepto el actor «root», tienen un padre.

• Relación padre-hijo: el actor que crea a otro actor se convierte en su padre.
• Supervisión: esta jerarquía es fundamental para la tolerancia a fallos de Akka. Los padres son responsables de supervisar a sus hijos (¡lo veremos con más detalle en la siguiente lección!).
• Direccionamiento basado en rutas: cada actor tiene una ruta única que refleja su posición en la jerarquía, como /user/parentActor/childActor.

ActorSystem es el punto de entrada para todas las aplicaciones Akka. Administra los recursos que necesitan los actores, incluidos los grupos de subprocesos y los planificadores.

Debe crearlo una sola vez por aplicación y usarlo después para crear sus actores de nivel superior. Es como el contenedor de toda su aplicación de actores.

Pruebe a ejecutar este código sencillo para crear un ActorSystem:

El comportamiento de un actor determina cómo reacciona ante distintos mensajes. En Scala, se define extendiendo el trait Actor e implementando el método receive.

• El método receive es una función parcial que asocia los mensajes entrantes con acciones específicas.
• Cada actor procesa los mensajes de uno en uno, de forma secuencial, lo que garantiza la seguridad de los hilos para su estado interno.

No interactúa directamente con las instancias de los actores. En su lugar, envía mensajes a un ActorRef. Piense en ActorRef como la dirección postal de un actor.

• Es un identificador que representa a un actor específico dentro del sistema.
• Los mensajes enviados a un ActorRef se colocan en el buzón del actor.
• Obtiene un ActorRef cuando crea un actor mediante actorOf.

La principal forma de comunicación entre actores es el envío de mensajes. La forma más habitual de enviar un mensaje es mediante el método ! (se pronuncia «tell»).

receiverActorRef ! "Your message here"

El método tell es asíncrono y de tipo fire-and-forget. Envía el mensaje sin esperar una respuesta.

Combine ahora la creación de un actor con el envío de mensajes:

Los actores pueden crear otros actores, formando la jerarquía que hemos descrito. Un actor principal crea sus actores secundarios mediante context.actorOf.

• context.actorOf: lo utiliza un actor para crear sus actores secundarios.
• system.actorOf: lo utiliza la aplicación para crear actores de nivel superior (guardianes).

La creación de actores secundarios ayuda a organizar el sistema, delegar tareas y aislar los fallos.

Los actores se comunican enviando mensajes al ActorRef de los demás. Un actor secundario puede obtener el ActorRef de su actor principal mediante context.parent. Para responder al remitente de un mensaje, un actor puede usar sender().

Veamos un ejemplo en el que un actor principal crea un actor secundario, le indica que realice una tarea y este informa cuando termina:

Los actores deben detenerse de forma controlada cuando ya no se necesitan, para liberar recursos. Puede detener un actor de varias formas:

• context.stop(self): el actor se detiene a sí mismo.
• context.stop(childRef): un actor principal detiene a uno de sus actores secundarios.
• system.stop(actorRef): se utiliza para los actores de nivel superior, aunque normalmente se detiene todo el sistema.

Cuando un actor se detiene, procesa todos los mensajes de su buzón antes de finalizar. Sus actores secundarios también se detienen de forma recursiva.

Considere el siguiente fragmento de código de un actor de Akka. ¿Cuál es la forma correcta de que MyChildActor envíe un mensaje a su actor principal creador, MyParentActor, si MyParentActor fue el remitente del mensaje inicial «request»?

¡Buen trabajo! En esta lección hemos visto aspectos fundamentales del diseño de sistemas de actores de Akka:

• Los actores se organizan en jerarquías, esenciales para la supervisión y la estructura.
• ActorSystem es el punto de entrada de su aplicación a Akka.
• El comportamiento de los actores se define mediante el método receive.
• ActorRef es la dirección a la que se envían los mensajes.
• Los actores se comunican de forma asíncrona mediante el método ! (tell).
• Los actores principales crean actores secundarios con context.actorOf, y estos pueden responder mediante sender().
• Los actores pueden detenerse de forma controlada mediante context.stop().

A continuación profundizaremos en las potentes estrategias de supervisión de Akka y en cómo gestionar los fallos correctamente.