Akka — le modèle d'acteurs

📄 Ressources du cours

🎥 Vidéos recommandées

• 🇫🇷 Introduction to Akka Actors with Java

  Akka · 09:40 · 50k vues — Johan Andrén from the Akka team at Lightbend shows a short live-coding introduction to using the new actor APIs in Akka 2.6 for Java applications. For more i...

• 🇫🇷 Using Actors (in Scala with Akka)

  Mark Lewis · 05:59 · 5k vues — This video gives a brief description of a problem that you might consider tackling with actors to help you see how you could think about your own problem sol...

• 🇬🇧 Introduction to Akka Actors with Java

  Akka · 09:40 · 50k vues — Johan Andrén from the Akka team at Lightbend shows a short live-coding introduction to using the new actor APIs in Akka 2.6 for Java applications. For more i...

1. Le modèle d'acteurs

Akka est le framework Scala/Java qui implémente ce modèle, inspiré directement d'Erlang (Ericsson, années 80).

2. ActorSystem — le conteneur

Un ActorSystem est le conteneur qui gère le cycle de vie de tous les acteurs. C'est le point d'entrée du framework.

import akka.actor._

object Main extends App {
   val system = ActorSystem("MySystem")        // creation du systeme

   // Creation d'acteurs
   val server = system.actorOf(Props[Server], "server")
   val client = system.actorOf(Props[Client], "client")

   // Envoi d'un message
   client ! "start"

   // Arret apres un delai
   Thread.sleep(5000)
   system.terminate()
}

3. Définir un acteur

Un acteur est une classe qui extends Actor et implémente la méthode receive.

class MonActeur extends Actor {
   def receive : Receive = {
      case message => ...
   }
}

Le type Receive est en réalité PartialFunction[Any, Unit]. La méthode receive est un pattern matching sur les messages.

Exemple complet — serveur pizza

import akka.actor.{Actor, ActorSystem, Props}

class PizzaServer extends Actor {
   def receive : Receive = {
      case "pizza" =>
         println("[Serveur] Préparation d'une pizza...")
         sender() ! "Votre pizza est prête !"
      case _ =>
         sender() ! "On ne peut pas vous aider !"
   }
}

Au reçu de "pizza", le serveur affiche un message et répond à l'expéditeur via sender(). Au reçu de tout autre message, il renvoie une excuse polie.

4. Envoyer et recevoir des messages

Opérateur ! — fire-and-forget

client ! "start"          // envoi simple, fire-and-forget
server ! Factorial(5)    // envoi d'un message structure (case class)

sender() — répondre à l'expéditeur

Dans le corps de receive, sender() renvoie l'ActorRef de l'acteur qui a envoyé le message courant.

case Factorial(n) =>
   val result = factorial(n)
   sender() ! Result(result)   // repondre a celui qui a demande

Définir les messages — case classes / objects

sealed trait Request
case class Factorial(n : Int) extends Request
case class SumFirst(n : Int) extends Request

case class Result(value : BigInt)

L'usage de sealed + case classes apporte les bénéfices du CM3 : exhaustivité vérifiée, pattern matching propre, == sémantique, pas de new.

5. Retrouver un acteur — actorSelection

Quand un acteur veut parler à un autre dont il n'a pas la référence directe, il utilise un chemin :

val server = context.actorSelection("/user/serverName")
server ! "pizza"

Hiérarchie des chemins

• /user/ : racine des acteurs créés par l'utilisateur
• /user/server : un acteur créé avec system.actorOf(Props[…], "server")
• /user/server/child : un acteur créé par server avec context.actorOf(…, "child")

6. Cycle de vie d'un acteur

Chaque acteur a des hooks qu'on peut surcharger pour initialiser ou nettoyer :

class Client(serverPath : String) extends Actor {
   val server = context.actorSelection(serverPath)

   override def preStart() : Unit = {
      server ! Factorial(5)        // envoi automatique au demarrage
      server ! SumFirst(10)
   }

   def receive : Receive = {
      case Result(value) =>
         println(s"${self.path.name} a reçu : $value")
   }
}

7. Pattern ask — attendre une réponse

Parfois on veut une réponse, pas juste envoyer-et-oublier. Le pattern ask renvoie un Future qui se résout quand l'acteur répond.

import akka.pattern.ask
import akka.util.Timeout
import scala.concurrent.duration._
import scala.concurrent.ExecutionContext.Implicits.global

implicit val timeout : Timeout = 5.seconds

val future = server ? Factorial(10)   // ? renvoie Future[Any]
future onComplete {
   case scala.util.Success(Result(v)) => println(v)
   case scala.util.Failure(e)          => println(s"erreur : $e")
}

8. Exemple complet — ActorCalcul

Le projet du cours combine tout ce qu'on a vu : sealed trait de messages, serveur qui répond, deux clients qui interagissent en parallèle.

import akka.actor._
import scala.concurrent.duration._
import akka.util.Timeout
import akka.pattern.ask
import scala.concurrent.ExecutionContext.Implicits.global

// ===== Messages =====
sealed trait Request
case class Factorial(n : Int) extends Request
case class SumFirst(n : Int) extends Request
case class Result(value : BigInt)

// ===== Serveur =====
class Server extends Actor {
   def factorial(n : Int) : BigInt =
      if (n <= 1) 1 else n * factorial(n - 1)

   def sumFirst(n : Int) : Int = (1 to n).sum

   def receive : Receive = {
      case Factorial(n) =>
         println(s"Serveur: calcul factorielle de $n")
         sender() ! Result(factorial(n))

      case SumFirst(n) =>
         println(s"Serveur: somme des $n premiers")
         sender() ! Result(sumFirst(n))
   }
}

// ===== Client =====
class Client(serverPath : String) extends Actor {
   val server = context.actorSelection(serverPath)
   implicit val timeout : Timeout = 5.seconds

   override def preStart() : Unit = {
      server ! Factorial(5)
      server ! SumFirst(10)
   }

   def receive : Receive = {
      case Result(value) =>
         println(s"${self.path.name} a reçu : $value")
   }
}

// ===== Main =====
object Main extends App {
   val system = ActorSystem("MySystem")
   val server = system.actorOf(Props[Server], "server")
   val client1 = system.actorOf(Props(new Client("/user/server")), "client1")
   val client2 = system.actorOf(Props(new Client("/user/server")), "client2")
   Thread.sleep(5000)
   system.terminate()
}

Sortie attendue (ordre variable) :

Serveur: calcul factorielle de 5
Serveur: somme des 10 premiers
client1 a reçu : 120
client1 a reçu : 55
Serveur: calcul factorielle de 5
Serveur: somme des 10 premiers
client2 a reçu : 120
client2 a reçu : 55

L'ordre exact dépend de l'ordonnanceur — c'est le propre du modèle d'acteurs. Chaque acteur traite ses messages séquentiellement, mais les acteurs entre eux sont concurrents.

9. Le problème des philosophes (Dijkstra)

Solution 1 — Superviseur centralisé

Un acteur Superviseur contrôle l'accès aux fourchettes.

Principe :

• Un philosophe demande l'autorisation au superviseur avant de manger
• Le superviseur vérifie si les deux fourchettes sont disponibles
• Si oui ⇒ il accorde l'autorisation
• Sinon ⇒ le philosophe attend
• Après avoir mangé, le philosophe informe le superviseur qu'il libère les fourchettes

Variables d'état du superviseur : tableau[Int] indiquant pour chaque fourchette si elle est libre (true) ou prise (false).

Solution 2 — Distribuée (sans superviseur)

Pas de processus central. Chaque fourchette est un acteur. Un philosophe communique avec ses deux voisines.

Stratégie :

• Un philosophe prend d'abord la fourchette de numéro le plus petit
• Puis la fourchette de numéro le plus grand
• Une fourchette n'est utilisée que par un seul philosophe à la fois

★ Réviser le chapitre

🃏 Flashcards

↻ Tout retourner

✎ Quiz éclair

❓ Q/R