Actor Model Pattern in Java: Building Concurrent Systems with Elegance

About 2 min

Also Known As

Message-passing concurrency
Actor-based concurrency

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

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

Akka Framework
Erlang and Elixir concurrency
Microsoft Orleans
JVM-based game engines and simulators

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

References and Credits

Programming Erlang, Joe Armstrong
Reactive Design Patterns, Roland Kuhn
The Actor Model in 10 Minutes, InfoQ Article
Akka Documentation