# Actor Model

The Actor Model is a conceptual model to deal with concurrent computation. It treats "actors" as the universal primitives of concurrent computation. In response to a message that it receives, an actor can: make local decisions, create more actors, send more messages, and determine how to respond to the next message received.

## 1. Core Concepts

*   **Actor:** The fundamental unit of computation. It encapsulates state and behavior.
*   **Mailbox:** Each actor has a mailbox (queue) where incoming messages are stored until the actor processes them.
*   **Message Passing:** Actors communicate *only* by sending asynchronous messages. They never share memory.

## 2. "No Shared State"

Unlike traditional threading models where threads share memory (leading to locks, race conditions, and deadlocks), actors are completely isolated.
*   State is private to the actor.
*   To change an actor's state, you must send it a message.
*   The actor processes messages one at a time (single-threaded within the actor), eliminating the need for locks.

## 3. Fault Tolerance (Let it Crash)

The Actor Model (popularized by Erlang) introduces a unique approach to error handling: **"Let it Crash"**.
*   **Supervision Hierarchies:** Actors form a tree structure. Parents supervise their children.
*   **Recovery:** If a child actor crashes, the parent decides what to do (Restart, Resume, Stop, or Escalate).
*   **Self-Healing:** Systems can automatically recover from failures without human intervention.

## 4. Implementations

### Erlang / Elixir (OTP)
The most famous implementation. Erlang was built for telecom systems requiring 99.9999999% reliability.
*   **Lightweight:** You can run millions of actors (processes) on a single machine.

### Akka (Java / Scala)
A toolkit and runtime for building highly concurrent, distributed, and resilient message-driven applications on the JVM.

### Microsoft Orleans / Akka.NET
Implementations for the .NET ecosystem. Orleans introduces "Virtual Actors" (Grains) that are automatically activated/deactivated.

## 5. Example (Conceptual)

```python
# Pseudo-code
class BankAccountActor:
    def __init__(self):
        self.balance = 0

    def receive(self, message):
        if message.type == "DEPOSIT":
            self.balance += message.amount
        elif message.type == "WITHDRAW":
            if self.balance >= message.amount:
                self.balance -= message.amount
            else:
                print("Insufficient funds")
        elif message.type == "GET_BALANCE":
            sender.send(self.balance)
```

[[programming/distributed-systems]]
[[programming/microservices-architecture]]
[[programming/asynchronous-programming]]
[[programming/reactive-programming]]