java-design-patterns/localization/de/actor-model/README.md

shortTitle, category, language, tag

shortTitle	category	language	tag
Actor Model	Concurrency	de	Concurrency Messaging Isolation Asynchronous Distributed Systems Actor Model

Alternativbezeichnungen

• Message-passing concurrency
• Actor-based concurrency

---

Zweck

Das Actor-Model-Pattern ermöglicht die Konstruktion von hochparallelen fehlertoleranten verteilten Systemen, indem es isolierte Komponenten (Akteure) verwendet, die ausschließlich über asynchronen Nachrichtenaustausch interagieren.

Detaillierte Erklärung

---

📦 Reales Beispiel

Stellen Sie sich ein Kundendienstsystem vor.

• Jeder Kundendienstmitarbeiter ist ein Aktor.
• Kunden senden Anfragen (Nachrichten) an die Mitarbeiter.
• Jeder Mitarbeiter behandelt zu einem bestimmten Zeitpunkt genau eine Anfrage und kann diese asynchron beantworten, ohne dabei anderen Mitarbeitern in die Quere zu kommen.

---

🧠 In einfachen Worten

"Aktoren sind wie unabhängige Arbeiter, die keine Ressourcen teilen und nur über Nachrichten kommunizieren."

---

📖 Wikipedia sagt

Das Actor Model ist ein mathematisches Modell für parallele Informationsverarbeitung, das "Aktoren" als universelle Ausführer von Aufgaben betrachtet.

---

🧹 Klassendiagramm

---

Programmbeispiel in Java

Actor.java

public abstract class Actor implements Runnable {

    @Setter
    @Getter
    private String actorId;
    private final BlockingQueue<Message> mailbox = new LinkedBlockingQueue<>();
    private volatile boolean active = true; 


    public void send(Message message) {
        mailbox.add(message); 
    }

    public void stop() {
        active = false; 
    }

    @Override
    public void run() {
        
    }

    protected abstract void onReceive(Message message);
}

Message.java

@AllArgsConstructor
@Getter
@Setter
public class Message {
    private final String content;
    private final String senderId;
}

ActorSystem.java

public class ActorSystem {
    public void startActor(Actor actor) {
        String actorId = "actor-" + idCounter.incrementAndGet(); // Generate a new and unique ID
        actor.setActorId(actorId); // assign the actor it's ID
        actorRegister.put(actorId, actor); // Register and save the actor with it's ID
        executor.submit(actor); // Run the actor in a thread
    }
    public Actor getActorById(String actorId) {
        return actorRegister.get(actorId); //  Find by Id
    }

    public void shutdown() {
        executor.shutdownNow(); // Stop all threads
    }
}

App.java

public class App {
  public static void main(String[] args) {
      ActorSystem system = new ActorSystem();
      Actor srijan = new ExampleActor(system);
      Actor ansh = new ExampleActor2(system);

      system.startActor(srijan);
      system.startActor(ansh);
      ansh.send(new Message("Hello ansh", srijan.getActorId()));
      srijan.send(new Message("Hello srijan!", ansh.getActorId()));

      Thread.sleep(1000); // Give time for messages to process

      srijan.stop(); // Stop the actor gracefully
      ansh.stop();
      system.shutdown(); // Stop the actor system
  }
}

---

Verwendung

• Bei der Konstruktion paralleler oder verteilter Systeme
• Wenn keine veränderlichen Zustände geteilt werden sollen
• Wenn asynchrone, nachrichtenbasierte Kommunikation benötigt wird
• Wenn die Komponenten isoliert und lose gekoppelt sein sollen.

---

Tutorials

• Baeldung – Akka with Java
• Vaughn Vernon – Reactive Messaging Patterns

---

Reale Anwendungen

• Akka Framework
• Concurrency in Erlang und Elixir
• Microsoft Orleans
• JVM-basierte Spiel-Engines und Simulatoren

---

Vor- und Nachteile

✅ Vorteile

• Unterstützt hohes Maß an Parallelität
• Leichte Skalierbarkeit über Zahl der Threads oder Prozessoren.
• Fehlerisolation und -behebbarkeit.
• Geordnete Nachrichten in den Aktoren

⚠️ Nachteile

• Schwierigeres Debugging wegen asynchronen Verhaltens
• Leichte Performance-Einbußen durch die Nachrichten-Warteschlangen
• Komplexeres Design als bei einfachem Methodenaufruf

---

Verwandte Patterns

• Command Pattern
• Mediator Pattern
• Event-Driven Architecture
• Observer Pattern

---

Quellen

• Programming Erlang, Joe Armstrong
• Reactive Design Patterns, Roland Kuhn
• The Actor Model in 10 Minutes, InfoQ Article
• Akka Documentation