1.
Diana ORTEGA
@dicaormu

2.
Paper and Book
Charles Antony Richard Hoare
“A paradigm for expressing
concurrency based on
message-passing”

3.
Texte ici
Communicating Sequential Processes
Agenda
● Definitions : concurrency, parallelism, etc
● How do we usually deal with concurrency?
● Communicating Sequential Processes (CSP) and Actors
● Conclusion and takeaways

4.
Go!

5.
Communicating Sequential Processes
Definitions
Process

6.
Communicating Sequential Processes
Definitions
Process
● Behaviour pattern of an object
● Implemented by functions
● Actions
Object
behaviour()

7.
Communicating Sequential Processes
Definitions
Process
● Behaviour pattern of an object
● Implemented by functions
● Actions http://www.designmethodsandprocesses.co.uk/
public int function(int x){
System.out.println("hello");
…..
return 1;
}

8.
Communicating Sequential Processes
Definitions
Process
● Behaviour pattern of an object
● Implemented by functions
● Actions

9.
Texte ici
Concurrency vs Parallelism
Communicating Sequential Processes
Definitions

10.
Parallelism in real life

11.
Texte ici
Time
Process
Process
Process
Time
Process
Process
Process
Process
Concurrency enables parallelism
Definitions: Concurrency vs Parallelism
Communicating Sequential Processes

12.
Texte ici
Process 1 Process 2
Communicating Sequential Processes
Interaction sharing memory

13.
Texte ici
Process 1 Process 2
Communicating Sequential Processes
Interaction sharing memory

14.
Texte ici
Process 1 Process 2
Communicating Sequential Processes
Interaction sharing memory

15.
Texte ici
Process 1 Process 2
Communicating Sequential Processes
Interaction sharing memory

16.
Texte ici
Process 1 Process 2
Communicating Sequential Processes
Interaction sharing memory

17.
Texte ici
Process 1 Process 2
Communicating Sequential Processes
Interaction sharing memory

18.
Texte ici
Process 1 Process 2
Communicating Sequential Processes
Interaction sharing memory

19.
Texte ici
● How do I write in the same space of memory?
● What if a process crashes and it has a lock?
● Where do I locate this space?
Process 1 Process 2
Communicating Sequential Processes
Interaction sharing memory

20.
Texte ici
Communicating Sequential Processes
Interaction sharing memory
Mutex Locks Semaphores
Threads

21.
Texte ici
Interaction sharing memory
● Callback hell
● Fragmented logic
● How do we converge when we need to
handle state?

22.
Texte ici
Communicating Sequential Processes
Interaction sharing memory

23.
Deadlocks or race conditions
Foto: http://revistacorrientes.com/

24.
Texte ici
● CSP
● Actor model
● Others (Amorphous computing, Flow-based programming)
Interaction by message passing
Communicating Sequential Processes

25.
Texte ici
Reasoning
● Look around you, What do you see?
● A complex world interacting, with
independently behaving pieces
Communicating Sequential Processes

26.
Definitions: Concurrent process

27.
Texte ici
Communicating Sequential Processes
CSP (original)
Coroutines Subroutines

28.
Texte ici
Communicating Sequential Processes
CSP (original)
Coroutines Subroutines
Processes

29.
Texte ici
Communicating Sequential Processes
CSP (original)
Coroutine A
Coroutine B
Communication by
process name
Communication
by port
subroutine C

30.
Texte ici
Communicating Sequential Processes
CSP (original)
Coroutine A
Coroutine B
Communication by
process name
Communication
by port
subroutine C
syntax?

31.
Texte ici<input_command>::=<source>?<target_variable>
<output_command>::=<destination>!<expression>
<source>::=<process_name>
<destination>::=<process_name>
<process_name>::=<identifier>|<identifier>(<subscripts>)
<subscripts>::=<integer_expression>,{<integer_expression>}
<target_variable> :.---<simple_variable>l<structured_target>
<structured_target> :.---<constructor>(<target_variable_list>)
<target_variable_list> :~ <empty>[<target_variable>
{,<target_variable>}
Communicating Sequential Processes
Csp: communication

32.
Texte ici<input_command>::=<source>?<target_variable>
<output_command>::=<destination>!<expression>
<source>::=<process_name>
<destination>::=<process_name>
<process_name>::=<identifier>|<identifier>(<subscripts>)
<subscripts>::=<integer_expression>,{<integer_expression>}
<target_variable> :.---<simple_variable>l<structured_target>
<structured_target> :.---<constructor>(<target_variable_list>)
<target_variable_list> :~ <empty>[<target_variable>
{,<target_variable>}
Communicating Sequential Processes
Csp: communication

33.
Texte ici<input_command>::=<source>?<target_variable>
<output_command>::=<destination>!<expression>
<source>::=<process_name>
<destination>::=<process_name>
<process_name>::=<identifier>|<identifier>(<subscripts>)
<subscripts>::=<integer_expression>,{<integer_expression>}
<target_variable> :.---<simple_variable>l<structured_target>
<structured_target> :.---<constructor>(<target_variable_list>)
<target_variable_list> :~ <empty>[<target_variable>
{,<target_variable>}
Communicating Sequential Processes
Csp: communication

34.
Texte ici<input_command>::=<source>?<target_variable>
<output_command>::=<destination>!<expression>
<source>::=<process_name>
<destination>::=<process_name>
<process_name>::=<identifier>|<identifier>(<subscripts>)
<subscripts>::=<integer_expression>,{<integer_expression>}
<target_variable> :.---<simple_variable>l<structured_target>
<structured_target> :.---<constructor>(<target_variable_list>)
<target_variable_list> :~ <empty>[<target_variable>
{,<target_variable>}
Communicating Sequential Processes
Csp: communication

35.
Texte ici
αc(P)={v |c.v ∈αP}
Communicating Sequential Processes
What does CSP say?

36.
Texte ici
αc(P)={v |c.v ∈αP}
Communicating Sequential Processes
What does CSP say?
ProcessProcess

37.
Texte ici
αc(P)={v |c.v ∈αP}
Communicating Sequential Processes
What does CSP say?
Value of
message

38.
Texte ici
αc(P)={v |c.v ∈αP}
Communicating Sequential Processes
What does CSP say?
communication
event

39.
Texte ici
αc(P)={v |c.v ∈αP}
Communicating Sequential Processes
What does CSP say?
Channels have type

40.
Texte ici
Process1 Process2
Communicating Sequential Processes
CSP

41.
Texte ici
Process1 Process2
Communicating Sequential Processes
CSP
Channel

42.
Texte ici
Process1 Process2
Communicating Sequential Processes
CSP
Channel

43.
Texte ici
“The Actor model adopts the philosophy
that everything is an actor. ”
Wikipedia
Communicating Sequential Processes
Actor model

44.
Texte ici
Actor1 Actor2
Communicating Sequential Processes
Actor model

45.
Texte ici
Actor1 Actor2
MailBox MailBox
Communicating Sequential Processes
Actor model

46.
Texte ici
Actor1 Actor2
MailBox MailBox
Communicating Sequential Processes
Actor model

47.
Texte iciActor System
Address
Address
Address
Communicating Sequential Processes
● processing
● storage
● communication
Actors

48.
Texte ici
Communicating Sequential Processes
CSP and Actors
Program

49.
Texte ici
Communicating Sequential Processes
CSP and Actors
Process Process Process Process

50.
Texte ici
Communicating Sequential Processes
CSP and Actors
Process1 Process2 Process3 Process4
I speak CSP!! me too!! :D
I’m an
Actor
me
too!

51.
Texte ici
Sending first

52.
Texte ici
Time Time
CSP Actors
Communicating Sequential Processes
CSP and Actors

53.
Texte ici
Time Time
Process1 writing
Actor writing
Communicating Sequential Processes
CSP and Actors

54.
Texte ici
Time Time
Process1 writing
Actors
Communicating Sequential Processes
CSP and Actors
Process1 waiting

55.
Texte ici
Time Time
Process2 reading
Actors
Communicating Sequential Processes
CSP and Actors
Process1 writing
Process1 waiting

56.
Texte ici
Time Time
Actors
Communicating Sequential Processes
CSP and Actors
Process2 reading

57.
Texte ici
Reading first

58.
Texte ici
Time Time
Process1 waiting
Communicating Sequential Processes
CSP and Actors
Actor1 waiting

59.
Texte ici
Time Time
Process1 waiting
Communicating Sequential Processes
CSP and Actors
Actor1 waiting
Process2 Writing Actor2 Writing

60.
Texte ici
Time Time
Process1 waiting
Communicating Sequential Processes
CSP and Actors
Actor1 waiting
Process2 Writing Actor2 Writing
Process1 reading Actor1 reading

61.
Texte ici
Time Time
Process1 waiting
Communicating Sequential Processes
CSP and Actors
Actor1 waiting
Process2 Writing Actor2 Writing
Process1 reading Actor1 reading
Process1 Processing Actor1 processing

62.
Texte ici
Time Time
Process1 waiting
Communicating Sequential Processes
CSP and Actors
Actor1 waiting
Process2 Writing Actor2 Writing
Process1 reading Actor1 reading
Process1 Processing Actor1 waiting

63.
Texte ici
The sieve of Eratosthenes.
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
Communicating Sequential Processes
Example

64.
Texte ici
The sieve of Eratosthenes.
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
p =2
look for multiples
starting by p^2
Communicating Sequential Processes
Example

65.
Texte ici
The sieve of Eratosthenes.
3 5 7 9
11 13 15 17 19
21 23 25 27 29
31 33 35 37 39
41 43 45 47 49
51 53 55 57 59
61 63 65 67 69
71 73 75 77 79
81 83 85 87 89
91 93 95 97 99
p =3
look for multiples
starting by p^2
Communicating Sequential Processes
Example

66.
Texte ici
The sieve of Eratosthenes.
5 7 11 13
17 19 23 25 29
31 35 37 41 43
47 49 53 55 59
61 65 67 71 73
77 79 83 85 89
91 95 97
p =5
look for multiples
starting by p^2
Communicating Sequential Processes
Example

67.
Texte ici
The sieve of Eratosthenes.
7 11 13 17
19 23 29 31 37
41 43 47 49 53
59 61 67 71 73
77 79 83 89 91
97
p =7
look for multiples
starting by p^2
Communicating Sequential Processes
Example

68.
Texte ici
The sieve of Eratosthenes.
11 13 17 19
23 29 31 37 41
43 47 53 59 61
67 71 73 79 83
89 97
p =11
look for multiples
starting by p^2
Communicating Sequential Processes
Example

69.
Texte ici
Communicating Sequential Processes
Solution CSP

70.
func main() {
ch := make(chan int) // Create a new channel.
go Generate(ch, 100) // Launch Generate goroutine.
Sieve(ch)
}
func Sieve(ch chan int) {
prime := <-ch
print(prime, "n")
ch1 := make(chan int)
go Filter(ch, ch1, prime)
Sieve(ch1)
}

71.
func Generate(ch chan<- int, number int) {
for i := 2; i < number; i++ {
ch <- i // Send 'i' to channel 'ch'.
}
}
// Copy the values from channel 'in' to channel 'out',
// removing those divisible by 'prime'.
func Filter(in <-chan int, out chan<- int, prime int) {
for {
i := <-in // Receive value from 'in'.
if i%prime != 0 {
out <- i // Send 'i' to 'out'.
}
}
}

72.
Texte ici
func main() {
ch := make(chan int) // Create a new channel.
go Generate(ch, 100) // Launch Generate goroutine.
Sieve(ch)
}
ch: channel int
Communicating Sequential Processes
Explanation A channel in Go provides a
connection between two
goroutines, allowing them to
communicate.

73.
Texte ici
func main() {
ch := make(chan int) // Create a new channel.
go Generate(ch, 100) // Launch Generate goroutine.
Sieve(ch)
}
stack Generate
Communicating Sequential Processes
Explanation
ch: channel int
It's an independently
executing function,
launched by a go
statement.

74.
Texte ici
func Generate(ch chan<- int, number int) {
for i := 2; i < number; i++ {
ch <- i // Send 'i' to channel 'ch'.
}
}
Communicating Sequential Processes
Explanation
stack Generate
number := 100
i:=2
ch: channel int
i
2
Synchronisation, it waits for a receiver to be
ready.

75.
Texte ici
func main() {
ch := make(chan int) // Create a new channel.
go Generate(ch, 100) // Launch Generate goroutine.
Sieve(ch)
}
Communicating Sequential Processes
Explanation
stack Generate
ch: channel int
2

76.
Texte ici
func Sieve(ch chan int) {
prime := <-ch
print(prime, "n")
ch1 := make(chan int)
go Filter(ch, ch1, prime)
Sieve(ch1)
}
prime :=2
Communicating Sequential Processes
Explanation
stack Generate
ch: channel int
2
synchronization, it will wait
for a value to be sent

77.
Texte ici
func Sieve(ch chan int) {
prime := <-ch
print(prime, "n")
ch1 := make(chan int)
go Filter(ch, ch1, prime)
Sieve(ch1)
}
Communicating Sequential Processes
Explanation
stack Generate
ch: channel int
ch1: channel int

78.
Texte ici
func Sieve(ch chan int) {
prime := <-ch
print(prime, "n")
ch1 := make(chan int)
go Filter(ch, ch1, prime)
Sieve(ch1)
} stack Filter
Communicating Sequential Processes
Explanation
stack Generate
ch: channel int
ch1: channel int
Channels both
communicate and
synchronize

79.
Texte ici
func Sieve(ch chan int) {
prime := <-ch
print(prime, "n")
ch1 := make(chan int)
go Filter(ch, ch1, prime)
Sieve(ch1)
}
Communicating Sequential Processes
Explanation
stack Filterstack Generate
ch: channel int
ch1: channel int

80.
Texte ici
func Sieve(ch chan int) {
prime := <-ch
print(prime, "n")
ch1 := make(chan int)
go Filter(ch, ch1, prime)
Sieve(ch1)
}
prime :=...
Communicating Sequential Processes
Explanation
stack Filterstack Generate
ch: channel int
ch1 (new ch): channel int

81.
Texte ici
func Generate(ch chan<- int, number int) {
for i := 2; i < number; i++ {
ch <- i // Send 'i' to channel 'ch'.
}
}
Communicating Sequential Processes
Explanation
prime :=...
stack Filterstack Generate
number := 100
i:=3
ch: channel int
ch1 (new ch): channel int
i
3

82.
Texte ici
func Filter(in <-chan int, out chan<- int, prime int) {
for {
i := <-in // Receive value from 'in'.
if i%prime != 0 {
out <- i // Send 'i' to 'out'.
}
}
}
Communicating Sequential Processes
prime :=...
stack Filter
prime:=2
stack Generate
ch(now in): channel int
ch1 (now out): channel int
i:=33
Explanation
A sender and receiver must
both be ready to play their
part in the communication.
Otherwise we wait until they
are

83.
Texte ici
func Filter(in <-chan int, out chan<- int, prime int) {
for {
i := <-in // Receive value from 'in'.
if i%prime != 0 {
out <- i // Send 'i' to 'out'.
}
}
}
Communicating Sequential Processes
Explanation
prime :=...
stack Filter
prime:=2
stack Generate
ch(now in): channel int
ch1 (now out): channel int
i:=3
3

84.
Texte ici
func Sieve(ch chan int) {
prime := <-ch
print(prime, "n")
ch1 := make(chan int)
go Filter(ch, ch1, prime)
Sieve(ch1)
}
func Sieve(ch chan int) {
prime := <-ch
print(prime, "n")
ch1 := make(chan int)
go Filter(ch, ch1, prime)
Sieve(ch1)
}
prime := 3
Communicating Sequential Processes
Explanation
stack Filterstack Generate
ch: channel int
ch1 (new ch): channel int
3

85.
Texte ici
func Generate(ch chan<- int, number int) {
for i := 2; i < number; i++ {
ch <- i // Send 'i' to channel 'ch'.
}
}
Communicating Sequential Processes
Explanation
stack Filterstack Generate
number := 100
i:=4
ch: channel int
ch1: channel int
i
4

86.
Texte ici
func Filter(in <-chan int, out chan<- int, prime int) {
for {
i := <-in // Receive value from 'in'.
if i%prime != 0 {
out <- i // Send 'i' to 'out'.
}
}
}
Communicating Sequential Processes
Explanation
stack Filter
prime:=2
stack Generate
ch(now in): channel int
ch1(now out): channel int
i:=4
4

87.
Texte ici
func Filter(in <-chan int, out chan<- int, prime int) {
for {
i := <-in // Receive value from 'in'.
if i%prime != 0 {
out <- i // Send 'i' to 'out'.
}
}
}
Communicating Sequential Processes
Explanation
stack Filter
prime:=2
stack Generate
ch(now in): channel int
ch1(now out): channel int
i:=4

88.
Texte ici
And so on…..
Communicating Sequential Processes
Explanation

89.
Texte ici
Result
2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97

90.
Texte ici
Communicating Sequential Processes
Solution Actor system

91.
Texte ici
implicit val system = ActorSystem("EratosthenesSystem")
implicit val ec = system.dispatcher
Communicating Sequential Processes
Explanation

92.
Texte ici
val upper = 100
val eventualPrimes = PrimeFinderCalculator(upper)
eventualPrimes.onComplete {
case Success(primes) =>
println(primes)
system.terminate()
case Failure(error) =>
Console.err.println(error)
system.terminate()
}
Communicating Sequential Processes
Explanation

93.
Texte ici
object PrimeFinderCalculator {
def apply(upper: Int, nrOfWorkers: Int = 2)
(implicit system: ActorSystem, timeout: Timeout): Future[List[Int]] = {
val master = system.actorOf(Master.props(upper), name = Master.name)
system.actorOf(Eratosthenes.props(), name = Eratosthenes.name)
(master ? Master.Messages.FindPrimes).mapTo[List[Int]]
}
}
}
Communicating Sequential Processes
Explanation

94.
Texte iciActor System
/root
/user
/Eratosthenes:era
tosthenes
/Master:
master
Communicating Sequential Processes
Explanation

95.
Texte ici
object PrimeFinderCalculator {
def apply(upper: Int, nrOfWorkers: Int = 2)
(implicit system: ActorSystem, timeout: Timeout): Future[List[Int]] = {
val master = system.actorOf(Master.props(upper), name = Master.name)
system.actorOf(Eratosthenes.props(), name = Eratosthenes.name)
(master ? Master.Messages.FindPrimes).mapTo[List[Int]]
}
}
}
Communicating Sequential Processes
Explanation

96.
Texte iciActor System
/root
/user
/Eratosthenes:era
tosthenes
/Master:
master
Communicating Sequential Processes
findPrimes
Explanation

97.
Texte ici
class Master(upper: Int) extends Actor {
var client: Option[ActorRef] = None
def receive: Receive = {
case FindPrimes =>
client = Some(sender)
val sieveRef = context.actorSelection(s"/user/${Eratosthenes.name}")
sieveRef ! Eratosthenes.Messages.Sieve(self, Nil, (2 to upper).toList)
case Result(list) =>
client.foreach(_ ! list)
}
}
Messages are not
anonymous
Communicating Sequential Processes
Explanation

98.
Texte ici
class Master(upper: Int) extends Actor {
var client: Option[ActorRef] = None
def receive: Receive = {
case FindPrimes =>
client = Some(sender)
val sieveRef = context.actorSelection(s"/user/${Eratosthenes.name}")
sieveRef ! Eratosthenes.Messages.Sieve(self, Nil, (2 to upper).toList)
case Result(list) =>
client.foreach(_ ! list)
}
}
I know all actors in the system.
I can look for an actor in a path and send
messages
Communicating Sequential Processes
Explanation

99.
Texte iciActor System
/root
/user
/Eratosthenes:era
tosthenes
/Master:
master
Communicating Sequential Processes
Sieve(self,nil, [2,3,..])
Explanation

100.
Texte ici
class Eratosthenes extends Actor with ActorLogging {
def receive: Receive = {
case Sieve(parent, primes, remaining) =>
remaining match {
case Nil =>
parent ! Master.Messages.Result(primes)
case h :: tail =>
self ! Sieve(parent, primes ++ List(h), tail.filter { x => x % h != 0 })
}
}
}
Send message to itself with
remaining list
Explanation

101.
Texte iciActor System
/root
/user
/Eratosthenes:era
tosthenes
/Master:
master
Communicating Sequential Processes
Sieve(parent,[2], [3,5..])
Explanation

102.
Texte ici
class Eratosthenes extends Actor with ActorLogging {
def receive: Receive = {
case Sieve(parent, primes, remaining) =>
remaining match {
case Nil =>
parent ! Master.Messages.Result(primes)
case h :: tail =>
self ! Sieve(parent, primes ++ List(h), tail.filter { x => x % h != 0 })
}
}
}
send primes list to parent
Explanation

103.
Texte iciActor System
/root
/user
/Eratosthenes:era
tosthenes
/Master:
master
Communicating Sequential Processes
Result([2,3,5,7,...])
Explanation

104.
Texte ici
class Master(upper: Int) extends Actor {
var client: Option[ActorRef] = None
def receive: Receive = {
case FindPrimes =>
client = Some(sender)
val sieveRef = context.actorSelection(s"/user/${Eratosthenes.name}")
sieveRef ! Eratosthenes.Messages.Sieve(self, Nil, (2 to upper).toList)
case Result(list) =>
client.foreach(_ ! list)
}
}
send response
Communicating Sequential Processes
Explanation

105.
Texte ici
Communicating Sequential Processes
Result
2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97

106.
Texte ici
Building a small actor system using channels
Mixing metaphors
Process1 Actor1
Channel

107.
Texte ici
Building a small actor system using channels
Mixing metaphors
Actor1Process1Channel
Actors are directly adressable. Channels are anonymous

108.
Texte ici
Building a small actor system using channels
Mixing metaphors
Mailboxes are only addressable by owning actor
Actor1 Actor2
Mailbox actor1 Mailbox actor2

109.
Texte ici
Building a small actor system using channels
Mixing metaphors
Channels have type
Process1Channel (Int)

110.
Texte ici
Building a small actor system using channels
Mixing metaphors
In actor model, only receiver blocks
Process2ChannelProcess1

111.
Texte ici
● communicating haskell processes
● go
● Clojure
● Javascript(js-csp)
Communicating Sequential Processes
Who does csp?

112.
Texte ici
● erlang
● elixir
● Akka
Communicating Sequential Processes
Who does actors?

113.
Texte ici
Takeaways
Communicating Sequential Processes
Concurrent programming involves at least three distinct concerns: concurrency,
mutual exclusion, and synchronisation

114.
Texte ici
Takeaways
Communicating Sequential Processes
Use the right tool for the job

115.
Texte ici
Takeaways
Communicating Sequential Processes
Actors and channels are often confused, we saw a mailbox implementation through
channels to characterize them and “live” the differences

116.
func main() {
ch := make(chan int) // Create a new channel.
go Generate(ch, 100) // Launch Generate goroutine.
Sieve(ch)
}
func Sieve(ch chan int) {
prime := <-ch
print(prime, "n")
ch1 := make(chan int)
go Filter(ch, ch1, prime)
Sieve(ch1)
}
A channel in Go provides a
connection between two
goroutines, allowing them to
communicate.
It's an independently
executing function,
launched by a go
statement.
synchronization, it will wait
for a value to be sent
Channels both
communicate and
synchronize
channel int
stack Generate

117.
func Generate(ch chan<- int, number int) {
for i := 2; i < number; i++ {
ch <- i // Send 'i' to channel 'ch'.
}
}
// Copy the values from channel 'in' to channel 'out',
// removing those divisible by 'prime'.
func Filter(in <-chan int, out chan<- int, prime int) {
for {
i := <-in // Receive value from 'in'.
if i%prime != 0 {
out <- i // Send 'i' to 'out'.
}
}
}
Synchronisation, it waits for a receiver to be
ready.
A sender and receiver must
both be ready to play their
part in the communication.
Otherwise we wait until they
are

118.
Texte ici
Building a small actor system using channels
Mixing metaphors
Message ordering

119.
Texte ici
Building a small actor system using channels
Mixing metaphors
type Actor struct {
…...
mailbox chan interface{}
}
func (actor *Actor) doSomething(message interface{}) {
select {
case actor.mailbox <- message:
default:
//throw message away
}
}
func (actor *Actor) receive(){
for{
message := <- actor.mailbox
//deal with action
…...
}
}

120.
Texte ici
How many messages should we wait?
Mixing metaphors
1 message, the sender could block
∞ is not possible
n=?

121.
Texte ici
Communicating Sequential Processes
Building a channel using Actors

122.
defmodule Chan.Chan do
...
def loop do
receive do
{msg,caller} ->
cond do
is_integer(msg) -> Kernel.send(caller, msg)
true -> loop()
end
end
end
…
end
test "echo" do
{:ok, pid} = Chan.start_link()
Chan.send(pid, 1)
assert_receive 1
Chan.send(pid, :hi)
refute_receive :hi
end

123.
Texte ici
Building a channel using Actors
Building a channel using Actors
defmodule Chan.Chan do
...
def loop do
receive do
{msg,caller} ->
cond do
is_integer(msg) -> Kernel.send(caller, msg)
true -> loop()
end
end
end
…
end