Applied synchronization to prevent CPU usage.

Author: Francisco-G-P

twin/README.md

@@ -5,10 +5,10 @@ description: "Explore the Twin design pattern in Java with examples. Learn how t
 category: Structural
 language: en
 tag:
-  - Decoupling
-  - Object composition
-  - Performance
-  - Resilience
+    - Decoupling
+    - Object composition
+    - Performance
+    - Resilience
 ---
 
 ## Intent of Twin Design Pattern
@@ -21,11 +21,11 @@ Real-world example
 
 > An analogous real-world example of the Twin design pattern can be found in the relationship between a driver and a driving simulator. Imagine a driver (the first class) and a driving simulator (the second class) that both need to interact with the same set of vehicle controls (steering, acceleration, braking) and receive the same feedback (speed, engine status).
 >
-> Despite performing similar functions, the driver and the simulator cannot share a common base class because they operate in fundamentally different environments—one in the physical world and the other in a virtual environment. Instead, they are "twinned" to ensure consistent interaction with the vehicle controls and feedback mechanisms. This setup allows improvements or changes to be made to the simulator without affecting the driver and vice versa, maintaining the system's overall flexibility and resilience. 
+> Despite performing similar functions, the driver and the simulator cannot share a common base class because they operate in fundamentally different environments—one in the physical world and the other in a virtual environment. Instead, they are "twinned" to ensure consistent interaction with the vehicle controls and feedback mechanisms. This setup allows improvements or changes to be made to the simulator without affecting the driver and vice versa, maintaining the system's overall flexibility and resilience.
 
 In plain words
 
-> It provides a way to form two closely coupled subclasses that can act as a twin class having two ends. 
+> It provides a way to form two closely coupled subclasses that can act as a twin class having two ends.
 
 Wikipedia says
 
@@ -84,36 +84,47 @@ public class BallItem extends GameItem {
 public class BallThread extends Thread {
   @Setter
   private BallItem twin;
-  private volatile boolean isSuspended;
   private volatile boolean isRunning = true;
+  private boolean isSuspended = false;
 
   public void run() {
-    while (isRunning) {
-      if (!isSuspended) {
+    synchronized (this) {
+      while (isRunning) {
+        while (isSuspended) {
+          try {
+            wait();
+          } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+            return;
+          }
+        }
         twin.draw();
         twin.move();
-      }
-      try {
-        Thread.sleep(250);
-      } catch (InterruptedException e) {
-        throw new RuntimeException(e);
+        try {
+          Thread.sleep(250);
+        } catch (InterruptedException e) {
+          Thread.currentThread().interrupt();
+          return;
+        }
       }
     }
   }
 
-  public void suspendMe() {
+  public synchronized void suspendMe() {
     isSuspended = true;
-    LOGGER.info("Begin to suspend BallThread");
+    LOGGER.info("Suspending BallThread");
   }
 
-  public void resumeMe() {
+  public synchronized void resumeMe() {
     isSuspended = false;
-    LOGGER.info("Begin to resume BallThread");
+    notify();
+    LOGGER.info("Resuming BallThread");
   }
 
-  public void stopMe() {
-    this.isRunning = false;
-    this.isSuspended = true;
+  public synchronized void stopMe() {
+    isRunning = false;
+    isSuspended = false;
+    notify();
   }
 }
 ```
@@ -192,40 +203,40 @@ This setup allows `BallItem` and `BallThread` to act together as a single cohesi
 
 ## When to Use the Twin Pattern in Java
 
-* Use when you need to decouple classes that share common functionality but cannot inherit from a common base class due to various reasons such as the use of different frameworks or languages.
-* Useful in performance-critical applications where inheritance might introduce unnecessary overhead.
-* Applicable in systems requiring resilience through the ability to replace or update one of the twins without affecting the other.
+-   Use when you need to decouple classes that share common functionality but cannot inherit from a common base class due to various reasons such as the use of different frameworks or languages.
+-   Useful in performance-critical applications where inheritance might introduce unnecessary overhead.
+-   Applicable in systems requiring resilience through the ability to replace or update one of the twins without affecting the other.
 
 ## Twin Pattern Java Tutorials
 
-* [Twin – A Design Pattern for Modeling Multiple Inheritance (Hanspeter Mössenböck)](http://www.ssw.uni-linz.ac.at/Research/Papers/Moe99/Paper.pdf)
+-   [Twin – A Design Pattern for Modeling Multiple Inheritance (Hanspeter Mössenböck)](http://www.ssw.uni-linz.ac.at/Research/Papers/Moe99/Paper.pdf)
 
 ## Real-World Applications of Twin Pattern in Java
 
-* User interfaces where different frameworks are used for rendering and logic.
-* Systems integrating legacy code with new implementations where direct inheritance is not feasible.
+-   User interfaces where different frameworks are used for rendering and logic.
+-   Systems integrating legacy code with new implementations where direct inheritance is not feasible.
 
 ## Benefits and Trade-offs of Twin Pattern
 
 Benefits:
 
-* Reduces coupling between classes, promoting modularity and easier maintenance.
-* Improves flexibility and reuse of classes across different frameworks or languages.
-* Enhances performance by avoiding the overhead associated with inheritance.
+-   Reduces coupling between classes, promoting modularity and easier maintenance.
+-   Improves flexibility and reuse of classes across different frameworks or languages.
+-   Enhances performance by avoiding the overhead associated with inheritance.
 
 Trade-offs:
 
-* Can lead to code duplication if not managed properly.
-* Increased complexity in managing the interaction between twin classes.
+-   Can lead to code duplication if not managed properly.
+-   Increased complexity in managing the interaction between twin classes.
 
 ## Related Java Design Patterns
 
-* [Adapter](https://java-design-patterns.com/patterns/adapter/): Both patterns deal with compatibility issues, but Adapter focuses on converting interfaces while Twin deals with class collaboration without inheritance.
-* [Bridge](https://java-design-patterns.com/patterns/bridge/): Similar in decoupling abstraction from implementation, but Twin specifically avoids inheritance.
-* [Proxy](https://java-design-patterns.com/patterns/proxy/): Manages object access, similar to how Twin handles interaction, but Proxy typically focuses on control and logging.
+-   [Adapter](https://java-design-patterns.com/patterns/adapter/): Both patterns deal with compatibility issues, but Adapter focuses on converting interfaces while Twin deals with class collaboration without inheritance.
+-   [Bridge](https://java-design-patterns.com/patterns/bridge/): Similar in decoupling abstraction from implementation, but Twin specifically avoids inheritance.
+-   [Proxy](https://java-design-patterns.com/patterns/proxy/): Manages object access, similar to how Twin handles interaction, but Proxy typically focuses on control and logging.
 
 ## References and Credits
 
-* [Design Patterns: Elements of Reusable Object-Oriented Software](https://amzn.to/3w0pvKI)
-* [Java Design Patterns: A Hands-On Experience with Real-World Examples](https://amzn.to/3yhh525)
-* [Patterns of Enterprise Application Architecture](https://amzn.to/3WfKBPR)
+-   [Design Patterns: Elements of Reusable Object-Oriented Software](https://amzn.to/3w0pvKI)
+-   [Java Design Patterns: A Hands-On Experience with Real-World Examples](https://amzn.to/3yhh525)
+-   [Patterns of Enterprise Application Architecture](https://amzn.to/3WfKBPR)

twin/src/main/java/com/iluwatar/twin/BallThread.java

@@ -1,5 +1,6 @@
 /*
- * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt).
+ * This project is licensed under the MIT license. Module model-view-viewmodel
+ * is using ZK framework licensed under LGPL (see lgpl-3.0.txt).
  *
  * The MIT License
  * Copyright © 2014-2022 Ilkka Seppälä
@@ -28,8 +29,10 @@
 import lombok.extern.slf4j.Slf4j;
 
 /**
- * This class is a UI thread for drawing the {@link BallItem}, and provide the method for suspend
- * and resume. It holds the reference of {@link BallItem} to delegate the draw task.
+ * This class is a UI thread for drawing the {@link BallItem}, and provides
+ * methods to suspend
+ * and resume execution. It holds the reference of {@link BallItem} to delegate
+ * the draw task.
  */
 
 @Slf4j
@@ -38,41 +41,49 @@ public class BallThread extends Thread {
   @Setter
   private BallItem twin;
 
-  private volatile boolean isSuspended;
-
   private volatile boolean isRunning = true;
+  private boolean isSuspended = false; // Removed volatile, now synchronized.
 
   /**
    * Run the thread.
    */
   public void run() {
-
-    while (isRunning) {
-      if (!isSuspended) {
+    synchronized (this) {
+      while (isRunning) {
+        while (isSuspended) {
+          try {
+            wait(); // Puts the thread in waiting state.
+          } catch (InterruptedException e) {
+            Thread.currentThread().interrupt(); // Restores the interruption.
+            return;
+          }
+        }
         twin.draw();
         twin.move();
-      }
-      try {
-        Thread.sleep(250);
-      } catch (InterruptedException e) {
-        throw new RuntimeException(e);
+        try {
+          Thread.sleep(250);
+        } catch (InterruptedException e) {
+          Thread.currentThread().interrupt();
+          return;
+        }
       }
     }
   }
 
-  public void suspendMe() {
+  public synchronized void suspendMe() {
     isSuspended = true;
-    LOGGER.info("Begin to suspend BallThread");
+    LOGGER.info("Suspending BallThread");
   }
 
-  public void resumeMe() {
+  public synchronized void resumeMe() {
     isSuspended = false;
-    LOGGER.info("Begin to resume BallThread");
+    notify(); // Wakes up the thread from waiting state.
+    LOGGER.info("Resuming BallThread");
   }
 
-  public void stopMe() {
-    this.isRunning = false;
-    this.isSuspended = true;
+  public synchronized void stopMe() {
+    isRunning = false;
+    isSuspended = false;
+    notify(); // Makes sure the thread wakes up and exits (stops).
   }
 }
-