Confronta il modello ad attori e il CSP (canali). In che modo aiuta il message passing?

Question

IT Interview Practice · Accepted Answer

**Entrambi evitano lo stato mutabile condiviso facendo comunicare le entità concorrenti tramite messaggi invece che tramite lock — gli attori possiedono uno stato privato e inviano messaggi indirizzati; il CSP ha processi anonimi che passano valori attraverso i canali.** "Don't communicate by sharing memory; share memory by communicating."

## Modello ad attori (Erlang, Akka)

Ogni attore ha una mailbox privata e processa i messaggi uno alla volta. Gli attori sono nominati/indirizzati, inviano in modo asincrono (fire-and-forget) e non condividono mai stato — quindi non servono lock all'interno di un attore. I supervision tree riavviano gli attori andati in crash.

```text
Attore A ──invia msg──▶ [mailbox] Attore B  (B processa serialmente, stato proprio)
```

## CSP (Go, occam)

I processi sono anonimi; comunicano attraverso i **canali**. Un rendezvous di send/receive (i canali non bufferizzati si bloccano finché entrambi i lati non sono pronti) fornisce la sincronizzazione. L'entità nominata è il canale, non il processo.

```go
ch := make(chan int)
go func() { ch <- compute() }()   // la goroutine invia nel canale
result := <-ch                    // il main riceve; si blocca finché non viene inviato
```

## Differenze chiave

- **Indirizzamento**: gli attori si indirizzano a vicenda; il CSP indirizza i canali.
- **Accoppiamento**: le send degli attori sono async e bufferizzate (mailbox); la send CSP classica è un rendezvous sincrono.
- **Topologia**: i canali possono essere passati e multiplexati (`select` di Go); gli attori formano una gerarchia di supervisione.

## Perché è importante

Il message passing trasforma le race condition da memoria condivisa in gestione ordinata dei messaggi — lo stato di ogni entità è toccato da un solo thread, eliminando la maggior parte dei lock e rendendo locale il ragionamento. È il fondamento di sistemi scalabili e fault-tolerant (le telecomunicazioni Erlang, i servizi Go). Conoscere la distinzione attori-vs-CSP dimostra che sai scegliere la giusta architettura di concorrenza, non solo aggiungere thread e lock.

Modello ad attori (Erlang, Akka)

CSP (Go, occam)

Differenze chiave

Perché è importante

Domande correlate