Newer
Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
# 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
}
}
```