Skip to content

Files

Latest commit

Apr 22, 2025
fe522fd · Apr 22, 2025

History

History

actor-model

Folders and files

NameName
Last commit message
Last commit date

parent directory

..
Apr 22, 2025
Apr 22, 2025
Apr 22, 2025
Apr 22, 2025
title shortTitle description category language tag
Actor Model Pattern in Java: Building Concurrent Systems with Elegance
Actor Model
Explore the Actor Model pattern in Java with real-world examples and practical implementation. Learn how to build scalable, message-driven systems using actors, messages, and asynchronous communication.
Concurrency
en
Concurrency
Messaging
Isolation
Asynchronous
Distributed Systems
Actor Model

Also Known As

  • Message-passing concurrency
  • Actor-based concurrency

Intent of Actor Model Pattern

The Actor Model pattern enables the construction of highly concurrent, distributed, and fault-tolerant systems by using isolated components (actors) that interact exclusively through asynchronous message passing.


Detailed Explanation of Actor Model Pattern with Real-World Examples

📦 Real-world Example

Imagine a customer service system:

  • Each customer support agent is an actor.
  • Customers send questions (messages) to agents.
  • Each agent handles one request at a time and can respond asynchronously without interfering with other agents.

🧠 In Plain Words

"Actors are like independent workers that never share memory and only communicate through messages."


📖 Wikipedia Says

Actor model is a mathematical model of concurrent computation that treats "actors" as the universal primitives of concurrent computation.


🧹 Architecture Diagram

UML Class Diagram


Programmatic Example of Actor Model Pattern 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
  }
}

When to Use the Actor Model Pattern in Java

  • When building concurrent or distributed systems
  • When you want no shared mutable state
  • When you need asynchronous, message-driven communication
  • When components should be isolated and loosely coupled

Actor Model Pattern Java Tutorials


Real-World Applications of Actor Model Pattern in Java


Benefits and Trade-offs of Actor Model Pattern

✅ Benefits

  • High concurrency support
  • Easy scaling across threads or machines
  • Fault isolation and recovery
  • Message ordering within actors

⚠️ Trade-offs

  • Harder to debug due to asynchronous behavior
  • Slight performance overhead due to message queues
  • More complex to design than simple method calls

Related Java Design Patterns


References and Credits