Fondamenti del modello ad attori di Akka

Nelle applicazioni moderne, spesso le attività devono essere eseguite contemporaneamente. Questo si chiama concorrenza. Sebbene sia potente, la concorrenza comporta alcune difficoltà.

• Race condition: si verificano quando più thread tentano di accedere e modificare contemporaneamente dati condivisi, producendo risultati imprevedibili.
• Deadlock: si verificano quando due o più thread sono bloccati indefinitamente, in attesa che gli altri rilascino le risorse.

I modelli tradizionali basati sui thread possono essere complessi e soggetti a errori quando si affrontano questi problemi.

Il modello Actor offre un metodo efficace per gestire la concorrenza. Invece di condividere la memoria, gli actor comunicano esclusivamente inviandosi messaggi.

• Isolamento: ogni actor ha un proprio stato privato, a cui nessun altro actor può accedere direttamente.
• Passaggio di messaggi: gli actor interagiscono inviando messaggi immutabili alle mailbox degli altri actor.
• Asincronia: l'invio dei messaggi non è bloccante; il mittente non attende una risposta.

Si possono immaginare gli actor come persone indipendenti, ciascuna con la propria scrivania (lo stato) e un servizio postale (il passaggio di messaggi).

Akka è un toolkit open source che porta il modello Actor in Scala (e Java). È progettato per creare applicazioni altamente concorrenti, distribuite e tolleranti ai guasti.

• Semplicità: Akka semplifica la programmazione concorrente astraendo i dettagli di basso livello dei thread.
• Scalabilità: consente di scalare facilmente le applicazioni da una singola macchina a un cluster di macchine.
• Resilienza: offre meccanismi integrati per gestire i guasti, consentendo ai sistemi di autoripararsi.

Akka aiuta a scrivere sistemi che "funzionano e basta", anche sotto carichi elevati o in presenza di guasti parziali.

Un actor Akka è un'unità fondamentale della concorrenza. Ogni actor dispone di:

• Comportamento: definito dal modo in cui reagisce ai messaggi.
• Mailbox: il luogo in cui vengono accodati i messaggi in arrivo. I messaggi vengono elaborati uno alla volta, in ordine.
• Stato privato: dati che appartengono esclusivamente all'actor e che possono essere modificati solo dall'actor stesso.
• ActorRef: un indirizzo univoco per inviare messaggi a questo actor.

Questo rigido isolamento previene errori comuni di concorrenza come le race condition.

Prima di poter creare gli actor, è necessario un ActorSystem. Questo è il punto di ingresso di Akka e gestisce tutti gli actor inclusi nel suo ambito.

Fornisce servizi come la pianificazione, la configurazione e una gerarchia per la supervisione (che verrà trattata più avanti).

Si provi a crearne uno:

Per creare un actor, si definisce una classe che estende il trait Actor di Akka e si implementa il metodo receive.

Il metodo receive definisce il modo in cui l'actor elabora i messaggi in arrivo. È una funzione parziale che esegue il matching sui tipi di messaggio.

Gli actor vengono creati (o "generati") usando il metodo actorOf di ActorSystem. Questo metodo restituisce un ActorRef.

Un ActorRef è un riferimento leggero e serializzabile a un actor. Lo si usa per inviargli messaggi, senza interagire mai direttamente con l'istanza dell'actor.

La comunicazione tra gli actor avviene esclusivamente tramite messaggi. I messaggi vengono inviati a un ActorRef utilizzando l'operatore ! (tell).

I messaggi vengono inviati in modo asincrono e sono generalmente case class immutabili o tipi semplici come String.

Gli actor hanno un ciclo di vita, dalla creazione alla terminazione. Akka mette a disposizione degli hook che consentono di eseguire operazioni di configurazione e pulizia:

• preStart(): viene chiamato subito prima che l'actor inizi a elaborare il primo messaggio. È utile per inizializzare le risorse.
• postStop(): viene chiamato dopo l'arresto dell'actor e prima che venga rimosso completamente dal sistema. È utile per rilasciare le risorse.

Comprendere il ciclo di vita è fondamentale per gestire efficacemente le risorse degli actor.

Gli actor sono organizzati in una gerarchia, analogamente a un file system. Ogni actor, ad eccezione dell'actor "root guardian", ha un parent.

• Supervisione: gli actor parent sono responsabili della supervisione dei propri figli. Se un actor figlio ha un errore, il parent decide come gestirlo (ad esempio, riavviandolo o arrestandolo).
• Percorso: ogni actor ha un percorso univoco, come /user/myActor/childActor, che riflette la sua posizione nella gerarchia.

Questa gerarchia è alla base delle funzionalità di tolleranza agli errori e resilienza di Akka.

Verifichiamo la Sua comprensione dei fondamenti dell'Actor Model di Akka.

Ottimo lavoro! In questa lezione ha appreso i concetti fondamentali dell'Actor Model di Akka:

• Le difficoltà della concorrenza tradizionale.
• I principi dell'Actor Model: isolamento, scambio di messaggi e assenza di stato condiviso.
• Il ruolo di Akka come toolkit per la creazione di sistemi basati su actor robusti.
• Come definire un ActorSystem e semplici actor in Scala.
• Come creare actor e inviare loro messaggi utilizzando un ActorRef.
• Le nozioni di base del ciclo di vita e della gerarchia degli actor.

Successivamente approfondiremo la progettazione dei sistemi basati su actor e la gestione di interazioni più complesse!