Compare the actor model and CSP (channels). How does message passing help?

Question

IT Interview Practice · Accepted Answer

**Both avoid shared mutable state by having concurrent entities communicate via messages instead of locks — actors own private state and send addressed messages; CSP has anonymous processes passing values through channels.** "Don't communicate by sharing memory; share memory by communicating."

## Actor model (Erlang, Akka)

Each actor has a private mailbox and processes messages one at a time. Actors are named/addressed, send asynchronously (fire-and-forget), and never share state — so no locks are needed inside an actor. Supervision trees restart crashed actors.

```text
Actor A ──send msg──▶ [mailbox] Actor B  (B processes serially, own state)
```

## CSP (Go, occam)

Processes are anonymous; they communicate through **channels**. A send/receive rendezvous (unbuffered channels block until both sides are ready) provides synchronization. The channel, not the process, is the named entity.

```go
ch := make(chan int)
go func() { ch <- compute() }()   // goroutine sends into channel
result := <-ch                    // main receives; blocks until sent
```

## Key differences

- **Addressing**: actors address each other; CSP addresses channels.
- **Coupling**: actor sends are async and buffered (mailbox); classic CSP send is synchronous rendezvous.
- **Topology**: channels can be passed around and multiplexed (Go's `select`); actors form a supervision hierarchy.

## Why it matters

Message passing turns shared-memory race conditions into ordered message handling — each entity's state is touched by one thread, eliminating most locks and making reasoning local. It's the foundation of scalable, fault-tolerant systems (Erlang telecom, Go services). Knowing the actor-vs-CSP distinction shows you can pick the right concurrency architecture, not just add threads and locks.

Actor model (Erlang, Akka)

CSP (Go, occam)

Key differences

Why it matters

Related questions