Active Object Pattern

Table of Content

What is Active Object Pattern?

---

The Active Object Pattern is a design pattern that decouples method execution from method invocation in order to improve concurrency, simplify synchronized access to an object and enhance modularity. In this pattern, an active object encapsulates a task or a set of tasks that can be executed asynchronously, without the calling thread having to wait for the task to complete. The active object receives requests through a queue, and each request is executed sequentially, one by one, by a dedicated scheduler thread.

This pattern can be particularly useful in cases where multiple threads need to access a shared resource that can be modified concurrently. By using an active object, all access to the shared resource can be serialized, which eliminates the need for explicit synchronization mechanisms and reduces the likelihood of race conditions and deadlocks.

The class that implements the active object pattern will contain a self-synchronization mechanism without using 'synchronized' methods.

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.

Overall, the Active Object Pattern is a powerful technique that can help improve application performance and scalability by reducing contention for shared resources and improving concurrency.

Advantage of Active Object Pattern

---

• Improved performance: By decoupling method invocation from method execution, the Active Object pattern can reduce contention for locks and other synchronization primitives, leading to improved performance in concurrent programs.
• Increased scalability: The absence of locks and other synchronization mechanisms can also improve the scalability of concurrent programs, making it easier to handle large numbers of threads or clients.
• Simplified error handling: Because each active object has its own thread of control, errors or exceptions that occur during method execution can be isolated and handled locally, without affecting the rest of the system.
• Improved modularity: The Active Object pattern encourages a modular design approach, where objects that require concurrent access are encapsulated in their own active objects. This can lead to cleaner, more maintainable code.
• Flexibility: The Active Object pattern can be used in a wide range of applications, from real-time systems to web applications.

Disadvantage of Active Object Pattern

---

• Increased complexity: The Active Object pattern introduces additional complexity into a system, which may make it harder to understand, test, and maintain.
• Higher memory usage: Each active object requires its own thread of control, which can increase memory usage in some cases.
• Overhead: The overhead of creating and managing threads can be significant, particularly in systems with large numbers of active objects.
• Limited applicability: The Active Object pattern is best suited to situations where multiple threads need to access a single object. In other situations, different concurrency patterns may be more appropriate.

Programmatic Example

---

    
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:

    
public class Orc extends ActiveCreature {

    public Orc(String name) {
        super(name);
    }
    
}

public static void main(String[] args) {  
    var app = new App();
    app.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());
    }
    Runtime.getRuntime().exit(1);
}
    

Class Diagram

---

Applicability

---

• GUI applications: The Active Object pattern can be used to handle UI events asynchronously, ensuring that the user interface remains responsive even when long-running operations are being performed in the background.
• Real-time systems: The Active Object pattern is well-suited for real-time systems that require high performance and low latency, such as audio and video processing systems.
• Distributed systems: The Active Object pattern can be used to implement distributed systems by providing a way to handle remote method invocations asynchronously.