Einführung in Akka Actors in Java

1. Einführung

Akka is an open-source library that helps to easily develop concurrent and distributed applications verwenden Java oder Scala, indem sie das Akteurmodell nutzen.

In diesem Tutorial werdenwe’ll present the basic features like defining actors, how they communicate and how we can kill them. In den letzten Anmerkungen werden wir auch einige bewährte Methoden für die Arbeit mit Akka erwähnen.

2. Das Schauspielermodell

Das Schauspieler-Modell ist für die Informatik-Community nicht neu. Es wurde erstmals 1973 von Carl Eddie Hewitt als theoretisches Modell für den Umgang mit gleichzeitigen Berechnungen eingeführt.

Es begann, seine praktische Anwendbarkeit zu demonstrieren, als die Softwareindustrie begann, die Fallstricke der Implementierung von gleichzeitigen und verteilten Anwendungen zu erkennen.

An actor represents an independent computation unit. Einige wichtige Merkmale sind:

Ein Akteur kapselt seinen Zustand und einen Teil der Anwendungslogik
Akteure interagieren nur durch asynchrone Nachrichten und niemals durch direkte Methodenaufrufe
Jeder Akteur hat eine eindeutige Adresse und ein Postfach, in dem andere Akteure Nachrichten übermitteln können
Der Akteur verarbeitet alle Nachrichten in der Mailbox in sequenzieller Reihenfolge (die Standardimplementierung der Mailbox ist eine FIFO-Warteschlange).
Das Akteurensystem ist in einer baumartigen Hierarchie organisiert
Ein Akteur kann andere Akteure erstellen, Nachrichten an jeden anderen Akteur senden und sich selbst anhalten, oder jeder Akteur, der erstellt wurde

2.1. Vorteile

Die gleichzeitige Entwicklung von Anwendungen ist schwierig, da wir uns mit Synchronisation, Sperren und gemeinsamem Speicher befassen müssen. Durch die Verwendung von Akka-Akteuren können wir problemlos asynchronen Code schreiben, ohne dass Sperren und Synchronisierungen erforderlich sind.

Einer der Vorteile der Verwendung von Nachrichten anstelle von Methodenaufrufen besteht darin, dassthe sender thread won’t block to wait for a return value when it sends a message to another actor. Der empfangende Akteur antwortet mit dem Ergebnis, indem er eine Antwortnachricht an den Absender sendet.

Ein weiterer großer Vorteil der Verwendung von Nachrichten besteht darin, dass wir uns nicht um die Synchronisierung in einer Multithread-Umgebung kümmern müssen. Dies liegt an der Tatsache, dassall the messages are processed sequentially.

Ein weiterer Vorteil des Akka-Darstellermodells ist die Fehlerbehandlung. Durch das Organisieren der Akteure in einer Hierarchie kann jeder Akteur seinen Elternteil über das Versagen informieren und dementsprechend handeln. Der übergeordnete Akteur kann entscheiden, ob die untergeordneten Akteure angehalten oder neu gestartet werden sollen.

3. Konfiguration

Um die Akka-Akteure zu nutzen, müssen wir die folgende Abhängigkeit vonMaven Central hinzufügen:


    com.typesafe.akka
    akka-actor_2.12
    2.5.11

4. Einen Schauspieler erstellen

Wie bereits erwähnt, sind die Akteure in einem Hierarchiesystem definiert. Alle Akteure, die eine gemeinsame Konfiguration haben, werden durchActorSystem. definiert

Im Moment definieren wir einfach einActorSystem mit der Standardkonfiguration und einem benutzerdefinierten Namen:

ActorSystem system = ActorSystem.create("test-system");

Obwohl wir noch keine Akteure erstellt haben, enthält das System bereits drei Hauptakteure:

Der Root-Guardian-Akteur hat die Adresse „/“, die, wie der Name sagt, die Wurzel der Akteurensystemhierarchie darstellt
der User Guardian Actor hat die Adresse "/ user". Dies ist das übergeordnete Element aller von uns definierten Akteure
der Akteur des Systemwächters mit der Adresse „/ system“. Dies ist das übergeordnete Element für alle vom Akka-System intern definierten Akteure

Jeder Akka-Akteur erweitert die abstrakte Klasse vonAbstractActorund implementiert die Methode voncreateReceive()für die Verarbeitung eingehender Nachrichten von anderen Akteuren:

public class MyActor extends AbstractActor {
    public Receive createReceive() {
        return receiveBuilder().build();
    }
}

This is the most basic actor we can create. Es kann Nachrichten von anderen Akteuren empfangen und verwirft diese, da inReceiveBuilder. keine übereinstimmenden Nachrichtenmuster definiert sind. Wir werden später in diesem Artikel über den Nachrichtenmusterabgleich sprechen.

Nachdem wir unseren ersten Schauspieler erstellt haben, sollten wir ihn inActorSystem aufnehmen:

ActorRef readingActorRef
  = system.actorOf(Props.create(MyActor.class), "my-actor");

4.1. Schauspieler-Konfiguration

The Props class contains the actor configuration. Wir können Dinge wie den Dispatcher, das Postfach oder die Bereitstellungskonfiguration konfigurieren. Diese Klasse ist unveränderlich und daher threadsicher, sodass sie beim Erstellen neuer Akteure gemeinsam genutzt werden kann.

Es wird dringend empfohlen und als bewährte Methode angesehen, die Factory-Methoden innerhalb des Actor-Objekts zu definieren, die die Erstellung desProps-Objekts übernehmen.

Definieren wir als Beispiel einen Akteur, der eine Textverarbeitung durchführt. Der Akteur erhält einString-Objekt, für das er die Verarbeitung durchführt:

public class ReadingActor extends AbstractActor {
    private String text;

    public static Props props(String text) {
        return Props.create(ReadingActor.class, text);
    }
    // ...
}

Um eine Instanz dieses Aktortyps zu erstellen, verwenden wir einfach die Factory-Methodeprops(), um das ArgumentStringan den Konstruktor zu übergeben:

ActorRef readingActorRef = system.actorOf(
  ReadingActor.props(TEXT), "readingActor");

Nachdem wir nun wissen, wie ein Akteur definiert wird, wollen wir sehen, wie er innerhalb des Akteursystems kommuniziert.

5. Actor Messaging

Um miteinander zu interagieren, können die Akteure Nachrichten von jedem anderen Akteur im System senden und empfangen. Diesemessages can be any type of object with the condition that it’s immutable.

It’s a best practice to define the messages inside the actor class. Dies hilft beim Schreiben von Code, der leicht zu verstehen ist und weiß, mit welchen Nachrichten ein Akteur umgehen kann.

5.1. Nachrichten senden

Innerhalb des Akka-Actor-Systems werden Nachrichten mit folgenden Methoden gesendet:

sagen()
Fragen()
nach vorne()

When we want to send a message and don’t expect a response, we can use the tell() method. Dies ist aus Sicht der Leistung die effizienteste Methode:

readingActorRef.tell(new ReadingActor.ReadLines(), ActorRef.noSender());

Der erste Parameter stellt die Nachricht dar, die wir an die AkteursadressereadingActorRef senden.

Der zweite Parameter gibt an, wer der Absender ist. Dies ist nützlich, wenn der Akteur, der die Nachricht empfängt, eine Antwort an einen anderen Akteur als den Absender senden muss (z. B. das übergeordnete Element des sendenden Akteurs).

Normalerweise können wir den zweiten Parameter aufnull oderActorRef.noSender() setzen, da wir keine Antwort erwarten. When we need a response back from an actor, we can use the ask() method:

CompletableFuture

TOC

Einführung in Akka Actors in Java