Scala for Backend Engineering & Functional Programming · Lektion

Actor-Systeme entwerfen

Lernen Sie, Actor-Hierarchien zu entwerfen und zu implementieren, Actor-Verhalten zu definieren sowie Nachrichten zu senden und zu empfangen.

Lektion 2 von 311 Schritte

Actor-Systeme entwerfen ist eine kostenlose Scala for Backend Engineering & Functional Programming-Lektion auf CoddyKit. Dies ist Lektion 2 von 3. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Scala for Backend Engineering & Functional Programming-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Scala for Backend Engineering & Functional Programming-Kurs umfasst insgesamt 3 Lektionen.

Akteursysteme entwerfen: Einführung

Willkommen in Lektion 2! In der vorherigen Lektion haben wir die Grundlagen des Akka Actor Model kennengelernt. Jetzt sehen wir uns das Entwerfen von Akka-Akteursystemen genauer an.

Ein gut entworfenes Akteursystem ist robust, skalierbar und leicht zu warten. Wir untersuchen, wie Sie Ihre Akteure strukturieren, ihr Verhalten definieren und eine effektive Kommunikation ermöglichen.

Akteur-Hierarchien verstehen

Akka-Akteure sind in einer baumartigen Hierarchie organisiert, ähnlich wie in einem Dateisystem. Jeder Akteur mit Ausnahme des Akteurs „root“ hat ein übergeordnetes Element.

Beziehung zwischen übergeordneten und untergeordneten Akteuren: Ein Akteur, der einen anderen Akteur erstellt, wird zu dessen übergeordnetem Akteur.
Überwachung: Diese Hierarchie ist entscheidend für Akkas Fehlertoleranz. Übergeordnete Akteure sind für die Überwachung ihrer untergeordneten Akteure verantwortlich (mehr dazu in der nächsten Lektion!).
Adressierung über Pfade: Jeder Akteur hat einen eindeutigen Pfad, der seine Position in der Hierarchie widerspiegelt, etwa /user/parentActor/childActor.

Ihr ActorSystem einrichten

Das ActorSystem ist der Einstiegspunkt für alle Akka-Anwendungen. Es verwaltet die für Akteure benötigten Ressourcen, einschließlich Thread-Pools und Scheduler.

Sie erstellen es einmal pro Anwendung und verwenden es anschließend, um Ihre Akteure der obersten Ebene zu erstellen. Es ist vergleichbar mit dem Container für Ihre gesamte Akteur-Anwendung.

Führen Sie diesen einfachen Code aus, um ein ActorSystem zu erstellen:

import akka.actor.ActorSystem

object AkkaSystemApp {
  def main(args: Array[String]): Unit = {
    // Create an ActorSystem with a unique name
    val system = ActorSystem("MyFirstActorSystem")
    println("ActorSystem created: " + system.name)

    // Remember to terminate the system when done!
    system.terminate()
  }
}

Akteurverhalten definieren

Das Verhalten eines Akteurs bestimmt, wie er auf verschiedene Nachrichten reagiert. In Scala definieren Sie dieses Verhalten, indem Sie das Actor-Trait erweitern und die Methode receive implementieren.

Die Methode receive ist eine partielle Funktion, die eingehende Nachrichten bestimmten Aktionen zuordnet.
Jeder Akteur verarbeitet Nachrichten einzeln und nacheinander. Dadurch wird die Thread-Sicherheit seines internen Zustands gewährleistet.

ActorRef: Die Adresse des Akteurs

Sie interagieren nicht direkt mit Akteurinstanzen. Stattdessen senden Sie Nachrichten an eine ActorRef. Stellen Sie sich ActorRef als Postadresse eines Akteurs vor.

Sie ist ein Handle, das einen bestimmten Akteur innerhalb des Systems repräsentiert.
An eine ActorRef gesendete Nachrichten werden in den Posteingang des Akteurs eingeordnet.
Sie erhalten eine ActorRef, wenn Sie mit actorOf einen Akteur erstellen.

Nachrichten an Akteure senden

Akteure kommunizieren hauptsächlich, indem sie Nachrichten senden. Die gebräuchlichste Methode zum Senden einer Nachricht ist die Methode ! (ausgesprochen „tell“).

receiverActorRef ! "Your message here"

Die Methode tell ist asynchron und folgt dem Prinzip fire-and-forget. Sie sendet die Nachricht und wartet nicht auf eine Antwort.

Sehen wir uns an, wie ein Akteur erstellt und ihm Nachrichten gesendet werden:

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

// 1. Define the actor's behavior
class GreeterActor extends Actor {
  def receive = {
    case "hello" => println(s"Greeter: Hello from ${self.path.name}!")
    case msg: String => println(s"Greeter: Received message: '$msg'")
    case _ => println("Greeter: Received something unexpected!")
  }
}

object SimpleActorApp {
  def main(args: Array[String]): Unit = {
    // 2. Create the ActorSystem
    val system = ActorSystem("GreeterSystem")

    // 3. Create a top-level actor and get its ActorRef
    val greeter: ActorRef = system.actorOf(Props[GreeterActor], "myGreeter")
    
    // 4. Send messages to the actor using '!'
    greeter ! "hello"
    greeter ! "How are you doing today?"
    greeter ! 123 // This will match the _ case

    // Give actors time to process messages, then terminate
    Thread.sleep(1000)
    system.terminate()
  }
}

Untergeordnete Akteure erstellen

Akteure können andere Akteure erstellen und so die besprochene Hierarchie bilden. Ein übergeordneter Akteur erstellt seine untergeordneten Akteure mit context.actorOf.

context.actorOf: Wird von einem Akteur verwendet, um untergeordnete Akteure zu erstellen.
system.actorOf: Wird von der Anwendung verwendet, um Akteure der obersten Ebene (Guardian-Akteure) zu erstellen.

Das Erstellen untergeordneter Akteure hilft dabei, Ihr System zu organisieren, Aufgaben zu delegieren und Fehler zu isolieren.

Kommunikation zwischen übergeordneten und untergeordneten Akteuren

Akteure kommunizieren, indem sie Nachrichten an die jeweilige ActorRef senden. Ein untergeordneter Akteur kann die ActorRef seines übergeordneten Akteurs über context.parent abrufen. Um dem Absender einer Nachricht zu antworten, kann ein Akteur sender() verwenden.

Sehen wir uns ein Beispiel an, in dem ein übergeordneter Akteur einen untergeordneten Akteur erstellt, ihn mit einer Aufgabe beauftragt und dieser nach Abschluss eine Rückmeldung sendet:

import akka.actor.{Actor, ActorRef, Props, ActorSystem}
import scala.concurrent.ExecutionContext.Implicits.global

// Child Actor Definition: Does work and replies to sender
class ChildActor extends Actor {
  def receive = {
    case "work" =>
      println(s"ChildActor (${self.path.name}): Doing work from ${sender().path.name}")
      sender() ! "done" // Reply 'done' to the sender (parent)
  }
}

// Parent Actor Definition: Creates child, sends work, receives reply
class ParentActor extends Actor {
  // Create a child actor when the parent starts
  val child: ActorRef = context.actorOf(Props[ChildActor], "myChild")

  def receive = {
    case "start" =>
      println("ParentActor: Kicking off child's work.")
      child ! "work" // Tell the child to do 'work'
    case "done" =>
      println(s"ParentActor: Child ${sender().path.name} reported 'done'.")
      context.stop(child) // Stop the child actor
      context.stop(self)   // Stop the parent actor
  }
}

object HierarchyApp {
  def main(args: Array[String]): Unit = {
    val system = ActorSystem("HierarchySystem")
    val parent: ActorRef = system.actorOf(Props[ParentActor], "parentActor")
    parent ! "start" // Start the interaction

    // Wait for the system to terminate (actors will stop themselves)
    system.whenTerminated.onComplete(_ => println("ActorSystem terminated."))
  }
}

Akteure ordnungsgemäß beenden

Akteure sollten ordnungsgemäß beendet werden, wenn sie nicht mehr benötigt werden, damit Ressourcen freigegeben werden. Sie können einen Akteur auf verschiedene Arten beenden:

context.stop(self): Ein Akteur beendet sich selbst.
context.stop(childRef): Ein übergeordneter Akteur beendet einen seiner untergeordneten Akteure.
system.stop(actorRef): Für Akteure der obersten Ebene; normalerweise beenden Sie jedoch das gesamte System.

Wenn ein Akteur beendet wird, verarbeitet er vor der Beendigung alle Nachrichten in seinem Posteingang. Seine untergeordneten Akteure werden ebenfalls rekursiv beendet.

Schnelltest: Akteurdesign

Betrachten Sie das folgende Akka-Akteur-Codefragment. Wie kann MyChildActor seinem erstellenden übergeordneten Akteur MyParentActor korrekt eine Nachricht senden, wenn MyParentActor der Absender der ursprünglichen Nachricht „request“ war?

Beantworte es in der interaktiven Lektion

Zusammenfassung: Akteursysteme entwerfen

Sehr gut! In dieser Lektion haben wir wichtige Aspekte des Entwerfens von Akka-Akteursystemen behandelt:

Akteure sind in Hierarchien organisiert, die für Überwachung und Struktur entscheidend sind.
Das ActorSystem ist der Einstiegspunkt Ihrer Anwendung in Akka.
Sie definieren das Verhalten eines Akteurs mit der Methode receive.
ActorRef ist die Adresse zum Senden von Nachrichten.
Akteure kommunizieren asynchron mit der Methode ! (tell).
Übergeordnete Akteure erstellen untergeordnete Akteure mit context.actorOf, und untergeordnete Akteure können mit sender() antworten.
Akteure können mit context.stop() ordnungsgemäß beendet werden.

Als Nächstes sehen wir uns Akkas leistungsstarke Überwachungsstrategien und den ordnungsgemäßen Umgang mit Fehlern genauer an!

Kostenlos starten

Lerne Scala mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse: 39
Lektionen: 143

Kostenlos lernen Den vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „Actor-Systeme entwerfen“ kostenlos?

Ja — der vollständige Text von „Actor-Systeme entwerfen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Scala for Backend Engineering & Functional Programming-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Scala for Backend Engineering & Functional Programming-Kurs umfasst insgesamt 3 Lektionen.

Was lerne ich in „Actor-Systeme entwerfen“?

Lernen Sie, Actor-Hierarchien zu entwerfen und zu implementieren, Actor-Verhalten zu definieren sowie Nachrichten zu senden und zu empfangen. Du übst Scala for Backend Engineering & Functional Programming mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Scala for Backend Engineering & Functional Programming zu starten?

Keine Vorkenntnisse erforderlich. Scala for Backend Engineering & Functional Programming auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 3.

Wie lange dauert die Lektion „Actor-Systeme entwerfen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Scala for Backend Engineering & Functional Programming-Lektion Code schreiben und ausführen?

Ja. Jede Scala for Backend Engineering & Functional Programming-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Scala for Backend Engineering & Functional Programming