docs: collecting parameter docs + formatting

active-object/README.md

@@ -3,84 +3,88 @@ title: Active Object
 category: Concurrency
 language: en
 tag:
- - Performance
+  - Performance
 ---
 
-
 ## Intent
 
-The Active Object design pattern provides a safe and reliable way to implement asynchronous behavior in concurrent systems. It achieves this by encapsulating tasks within objects that have their own thread and message queue. This separation keeps the main thread responsive and avoids issues like direct thread manipulation or shared state access.
+The Active Object design pattern provides a safe and reliable way to implement asynchronous behavior in concurrent
+systems. It achieves this by encapsulating tasks within objects that have their own thread and message queue. This
+separation keeps the main thread responsive and avoids issues like direct thread manipulation or shared state access.
 
 ## Explanation
 
-The class that implements the active object pattern will contain a self-synchronization mechanism without using 'synchronized' methods.
+The class that implements the active object pattern will contain a self-synchronization mechanism without using '
+synchronized' methods.
 
 Real-world example
 
->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.
+> 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.
 
 **Programmatic Example**
 
 ```java
-public abstract class ActiveCreature{
+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());
-            }
+      @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());
-        }
-      }
+                   @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());
-        }
-      }
+                   @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.
+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:
 
@@ -94,29 +98,30 @@ public class Orc extends ActiveCreature {
 }
 ```
 
-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:
+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 static void main(String[] args) {  
-    var app = new App();
+  public static void main(String[]args){
+    var app=new App();
     app.run();
-  }
-  
-  @Override
-  public void run() {
+    }
+
+@Override
+public void run(){
     ActiveCreature creature;
-    try {
-      for (int i = 0;i < creatures;i++) {
-        creature = new Orc(Orc.class.getSimpleName().toString() + i);
-        creature.eat();
-        creature.roam();
-      }
-      Thread.sleep(1000);
-    } catch (InterruptedException e) {
-      logger.error(e.getMessage());
+    try{
+    for(int i=0;i<creatures;i++){
+    creature=new Orc(Orc.class.getSimpleName().toString()+i);
+    creature.eat();
+    creature.roam();
+    }
+    Thread.sleep(1000);
+    }catch(InterruptedException e){
+    logger.error(e.getMessage());
     }
     Runtime.getRuntime().exit(1);
-  }
+    }
 ```
 
 ## Class diagram