docs: Create German README.md for Active Object

#2275
first text part

Author: sieberss

localization/de/active-object/README.md

@@ -0,0 +1,238 @@
+---
+shortTitle: Active Object
+category: Concurrency
+language: de
+tag:
+  - Asynchronous
+  - Decoupling
+  - Messaging
+  - Synchronization
+  - Thread management
+---
+
+## Zweck
+
+Active Object bietet eine zuverlässige Methode zur Behandlung asynchroner Prozesse, mit der reaktionsfähige Anwendungen 
+und effizientes Thread-Management gesichert werden.
+Dies wird dadurch erreicht, dass die einzelnen Aufgaben in Objekte gekapselt werden, die in eigenen Threads
+mit eigener Nachrichtenwarteschlange aktiv sind. Durch diese Trennung bleibt der Hauptthread
+reaktionsfähig und Probleme wie direkte Threadmanipulation oder gemeinsamer Zugriff auf Zustände werden vermieden.
+
+## Detaillierte Erklärung
+
+Reales Beispiel
+
+> Stellen Sie sich ein gut besuchtes Restaurant vor, in dem die Gäste Bestellungen bei den
+> Kellner aufgeben. Die Kellner gehen nicht selbst in die Küche, um die Essen selbst zuzubereiten,
+> sondern sie schreiben die Bestellungen auf Zettel und geben diese dem Küchenmanager.
+> Der Manager organisiert eine Gruppe von Köchen, die die verschiedenen Mahlzeiten parallel zubereiten.
+> Wenn ein Koch frei ist, nimmt er eine Bestellung aus der Warteschlange, bereitet das Essen zu
+> und benachrichtigt den Kellner, sobald es fertig zum Servieren ist.
+>
+> In dieser Analogie stehen die Kellner für die Client-Threads,
+> der Küchenmanager für den Thread-Scheduler, und die Köche für die Methodenausführung
+> in verschiedenen Threads.
+> Die Organisation ermöglicht es, dass die Kellner immer weiter Bestellungen annehmen können,
+> ohne durch die Essenszubereitung aufgehalten zu werden; so wie das Active-Object-Pattern
+> den Methodenaufruf von der Ausführung trennt, um die Effizienz zu verbessern.
+
+In einfachen Worten
+
+> Das Active-Object-Pattern trennt Methodenausführung und Methodenaufruf,
+> um Parallelitätsgrad und Reaktionsfähigkeit in Multithread-Anwendungen zu verbessern.
+
+Wikipedia sagt
+
+> Das Design-Pattern Active Object entkoppelt die Methodenausführung vom Methodenaufruf
+> für Objekte, die in ihrem jeweils eigenen Thread arbeiten.[1]
+> Ziel ist, Parallelität dadurch zu ermöglichen, dass Methoden asynchron aufgerufen werden und ein
+> Scheduler die Anfragen organisiert.
+>
+> Das Pattern besteht aus sechs Elementen.
+>
+> * Ein Proxy stellt für Clients ein Interface mit öffentlich zugänglichen Methoden zur Verfügung.
+> * Ein weiteres Interface definiert die Anfragen an ein aktives Objekt.
+> * Eine Liste offener Client-Anfragen.
+> * Ein Scheduler entscheidet, welche Anfrage als nächstes ausgeführt wird.
+> * Die Implementation der Methoden.
+> * Eine Callback-Variable zur Rückmeldung des Ergebnisses.
+
+Ablaufdiagramm
+
+![Active Object sequence diagram](./etc/active-object-sequence-diagram.png)
+
+
+## Programmatic Example of Active Object in Java
+
+This section explains how the Active Object design pattern works in Java, highlighting its use in asynchronous task management and concurrency control.
+
+The Orcs are known for their wildness and untameable soul. It seems like they have their own thread of control based on previous behavior. To implement a creature that has its own thread of control mechanism and expose its API only and not the execution itself, we can use the Active Object pattern.
+
+```java
+public abstract class ActiveCreature {
+    private final Logger logger = LoggerFactory.getLogger(ActiveCreature.class.getName());
+
+    private BlockingQueue<Runnable> requests;
+
+    private String name;
+
+    private Thread thread;
+
+    public ActiveCreature(String name) {
+        this.name = name;
+        this.requests = new LinkedBlockingQueue<Runnable>();
+        thread = new Thread(new Runnable() {
+            @Override
+            public void run() {
+                while (true) {
+                    try {
+                        requests.take().run();
+                    } catch (InterruptedException e) {
+                        logger.error(e.getMessage());
+                    }
+                }
+            }
+        }
+        );
+        thread.start();
+    }
+
+    public void eat() throws InterruptedException {
+        requests.put(new Runnable() {
+                         @Override
+                         public void run() {
+                             logger.info("{} is eating!", name());
+                             logger.info("{} has finished eating!", name());
+                         }
+                     }
+        );
+    }
+
+    public void roam() throws InterruptedException {
+        requests.put(new Runnable() {
+                         @Override
+                         public void run() {
+                             logger.info("{} has started to roam the wastelands.", name());
+                         }
+                     }
+        );
+    }
+
+    public String name() {
+        return this.name;
+    }
+}
+```
+
+We can see that any class that will extend the `ActiveCreature` class will have its own thread of control to invoke and execute methods.
+
+For example, the `Orc` class:
+
+```java
+public class Orc extends ActiveCreature {
+
+    public Orc(String name) {
+        super(name);
+    }
+}
+```
+
+Now, we can create multiple creatures such as orcs, tell them to eat and roam, and they will execute it on their own thread of control:
+
+```java
+public class App implements Runnable {
+
+    private static final Logger logger = LoggerFactory.getLogger(App.class.getName());
+
+    private static final int NUM_CREATURES = 3;
+
+    public static void main(String[] args) {
+        var app = new App();
+        app.run();
+    }
+
+    @Override
+    public void run() {
+        List<ActiveCreature> creatures = new ArrayList<>();
+        try {
+            for (int i = 0; i < NUM_CREATURES; i++) {
+                creatures.add(new Orc(Orc.class.getSimpleName() + i));
+                creatures.get(i).eat();
+                creatures.get(i).roam();
+            }
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            logger.error(e.getMessage());
+            Thread.currentThread().interrupt();
+        } finally {
+            for (int i = 0; i < NUM_CREATURES; i++) {
+                creatures.get(i).kill(0);
+            }
+        }
+    }
+}
+```
+
+Program output:
+
+```
+09:00:02.501 [Thread-0] INFO com.iluwatar.activeobject.ActiveCreature -- Orc0 is eating!
+09:00:02.501 [Thread-2] INFO com.iluwatar.activeobject.ActiveCreature -- Orc2 is eating!
+09:00:02.501 [Thread-1] INFO com.iluwatar.activeobject.ActiveCreature -- Orc1 is eating!
+09:00:02.504 [Thread-0] INFO com.iluwatar.activeobject.ActiveCreature -- Orc0 has finished eating!
+09:00:02.504 [Thread-1] INFO com.iluwatar.activeobject.ActiveCreature -- Orc1 has finished eating!
+09:00:02.504 [Thread-0] INFO com.iluwatar.activeobject.ActiveCreature -- Orc0 has started to roam in the wastelands.
+09:00:02.504 [Thread-2] INFO com.iluwatar.activeobject.ActiveCreature -- Orc2 has finished eating!
+09:00:02.504 [Thread-1] INFO com.iluwatar.activeobject.ActiveCreature -- Orc1 has started to roam in the wastelands.
+09:00:02.504 [Thread-2] INFO com.iluwatar.activeobject.ActiveCreature -- Orc2 has started to roam in the wastelands.
+```
+
+## When to Use the Active Object Pattern in Java
+
+Use the Active Object pattern in Java when:
+
+* when you need to handle asynchronous tasks without blocking the main thread, ensuring better performance and responsiveness.
+* When you need to interact with external resources asynchronously.
+* When you want to improve the responsiveness of your application.
+* When you need to manage concurrent tasks in a modular and maintainable way.
+
+## Active Object Pattern Java Tutorials
+
+* [Android and Java Concurrency: The Active Object Pattern(Douglas Schmidt)](https://www.youtube.com/watch?v=Cd8t2u5Qmvc)
+
+## Real-World Applications of Active Object Pattern in Java
+
+* Real-time trading systems where transaction requests are handled asynchronously.
+* GUIs where long-running tasks are executed in the background without freezing the user interface.
+* Game programming to handle concurrent updates to game state or AI computations.
+
+## Benefits and Trade-offs of Active Object Pattern
+
+Discover the benefits and trade-offs of using the Active Object pattern in Java, including improved thread safety and potential overhead concerns.
+
+Benefits:
+
+* Improves responsiveness of the main thread.
+* Encapsulates concurrency concerns within objects.
+* Promotes better code organization and maintainability.
+* Provides thread safety and avoids shared state access problems.
+
+Trade-offs:
+
+* Introduces additional overhead due to message passing and thread management.
+* May not be suitable for all types of concurrency problems.
+
+## Related Java Design Patterns
+
+* [Command](https://java-design-patterns.com/patterns/command/): Encapsulates a request as an object, similarly to how the Active Object pattern encapsulates method calls.
+* [Promise](https://java-design-patterns.com/patterns/promise/): Provides a means to retrieve the result of an asynchronous method call, often used in conjunction with Active Object.
+* [Proxy](https://java-design-patterns.com/patterns/proxy/): The Active Object pattern can use a proxy to handle method invocations asynchronously.
+
+## References and Credits
+
+* [Design Patterns: Elements of Reusable Object Software](https://amzn.to/3HYqrBE)
+* [Concurrent Programming in Java: Design Principles and Patterns](https://amzn.to/498SRVq)
+* [Java Concurrency in Practice](https://amzn.to/4aRMruW)
+* [Learning Concurrent Programming in Scala](https://amzn.to/3UE07nV)
+* [Pattern Languages of Program Design 3](https://amzn.to/3OI1j61)
+* [Pattern-Oriented Software Architecture Volume 2: Patterns for Concurrent and Networked Objects](https://amzn.to/3UgC24V)