Add exercises/solutions-5.md

exercises/solutions-5.md

+# Exercise 1 : Message Processing Semantics
+
+For the `Client1` actor, the only possible output is 1. The reason is that messages between two actors are guaranteed to be received in the order they were sent.
+
+For the `Client2` actor, either 0 or 1 can be printed. There are no restrictions on the order in which messages are processed in this case. It might be the case that the `Memory` actor receives the `Write` message from the `Client2` first, or the Read message from the `Proxy` first. The order in which the messages are sent by the `Client2` doesn't change the possible behaviours of the system. In the case both messages are sent through the `Proxy`, then the only possible output is 1, since in this case the messages between the `Client2` and `Proxy`, as well as between `Proxy` and `Memory`, are guaranteed to be handled in the same order they were sent.
+
+## Exercise 2 : The Josephus Problem
+
+```scala
+import akka.actor._
+
+class Soldier(number: Int) extends Actor {
+
+  import Soldier._
+
+  def receive: Receive = behavior(None, None, false)
+
+  def behavior(next: Option[ActorRef],
+               killer: Option[ActorRef],
+               mustAct: Boolean): Receive = {
+
+    case Death => next match {
+      case Some(myNext) =>
+        sender ! Next(myNext)
+        myNext ! Act
+        println("Soldier " + number + " dies.")
+        self ! PoisonPill
+
+      case None =>
+        context.become(behavior(
+          next = None,
+          killer = Some(sender),
+          mustAct = mustAct))
+    }
+
+    case Next(newNext) =>
+      if (newNext == self) {
+        println("Soldier " + number + " is last !")
+      } else if (!killer.isEmpty) {
+        killer.get ! Next(newNext)
+        newNext ! Act
+        println("Soldier " + number + " dies.")
+        self ! PoisonPill
+      } else if (mustAct) {
+        newNext ! Death
+        context.become(behavior(
+          next = None,
+          killer = None,
+          mustAct = false))
+      } else {
+        context.become(behavior(
+          next = Some(newNext),
+          killer = None,
+          mustAct = false))
+      }
+    }
+
+
+    case Act => next match {
+      case Some(myNext) =>
+        myNext ! Death
+        context.become(behavior(
+          next = None,
+          killer = killer,
+          mustAct = false))
+
+      case None =>
+        context.become(behavior(
+          next = None,
+          killer = killer,
+          mustAct = true))
+    }
+  }
+}
+
+
+object Soldier {
+  // The different messages that can be sent between the actors:
+
+  // The recipient should die.
+  case object Death
+
+  // The recipient should update its next reference.
+  case class Next(next: ActorRef)
+
+  // The recipient should act.
+  case object Act
+
+  def props(number: Int): Props = Props(new Soldier(number))
+}
+
+
+object Simulation {
+
+  import Soldier._
+
+  // Initialization
+  val system = ActorSystem("mySystem")
+
+  def start(n: Int) {
+    require(n >= 1)
+
+    // Creation of the actors.
+    val actors = Seq.tabulate(n) { (i: Int) =>
+      system.actorOf(Soldier.props(i), "Soldier" + i)
+    }
+
+    // Inform all actors of the next actor in the circle.
+    for (i <- 0 to (n - 2)) {
+      actors(i) ! Next(actors(i + 1))
+    }
+    actors(n - 1) ! Next(actors(0))
+
+    // Inform the first actor to start acting.
+    actors(0) ! Act
+  }
+}
+```