How the Go language can be used to implement a version of the Actor Model for concurrent programming. Talk given at the Golang UK conference, August 2016 Video: https://www.youtube.com/watch?v=yCbon_9yGVs

1. An Actor Model in Go
Bryan Boreham, Weaveworks
@bboreham

3. According to Wikipedia…
The actor model in computer science is a
mathematical model of concurrent computation that
treats "actors" as the universal primitives of
concurrent computation.

4. Actors’ Advocacy
• Good for highly concurrent systems
• Easier to write
• Easier to reason about

5. This has been a learning experience

6. Some predictions
• I’ll get to those later

7. My life as a Gopher

8. ConnectionMaker
Weave Net ConnectionMaker

9. ConnectionMaker
Weave Net ConnectionMaker

10. ConnectionMaker
Weave Net ConnectionMaker

11. ConnectionMaker Properties
• Async between callers and actions
• Sync during connection attempts
• Timer-driven events

12. Actor

13. Actors

14. Actor Outline in Go
• Actor → struct
+ goroutine
• Mailbox → chan
func StartActor() *Actor {
ch := make(chan action, size)
actor := &Actor{ ... }
go actor.actorLoop(ch)
return actor
}
func (actor *Actor) DoSomething() {
actor.actionChan <- something
}
func (actor *Actor) actorLoop(
ch <-chan action) {
for {
action := <-ch
// deal with action
}
}
🤔
🤔

15. ConnectionMaker in Go
type action func()
func (cm *ConnectionMaker) Add(address string) {
cm.actionChan <- func() {
cm.addConnection(address)
}
}

16. ConnectionMaker Loop
func (cm *ConnectionMaker) actorLoop(ch <-chan action) {
timer := time.NewTimer(duration)
for {
select {
case action := <-ch:
action()
case <-timer.C:
retryConnections()
}
}
}

17. Actions with return values
func (cm *ConnectionMaker) String() string {
resultChan := make(chan string, 0)
cm.actionChan <- func() {
resultChan <- cm.status()
}
return <-resultChan
}

18. What size should the chan be?
• 0
• 1
• N
• ∞

19. Non-blocking send
func (actor *SomeActor) TryTo(something) {
select {
case actor.actionChan <- func() {
// do the thing
}:
default:
// chan is full; throw it away
}
}

20. Back to the theory
• An actor can designate the behaviour to be used for the
next message it receives.
• Messages are sent to actors at addresses
• Compare CSP: processes are anonymous and
channels are named
• We use a pointer to the actor as its address
• Unbounded nondeterminism

21. In Practice
Pro:
• No lock/unlock
• Simple model
• Identifies goroutines
Con:
• Debugging/testing
• Single reader/writer
• No framework!

22. Deadlock, Feb 15 2015
localPeer
.queryLoop
connection
.queryLoop
handle
AddConnection
connection.
sendGossip
Message
handle
SetEstablished
localPeer.
ConnEstablished
chan
chan

23. Predictions
• You’ll say “just use a mutex”
• You’ll say “that’s what I’m doing anyway”

24. Summary
• “Do not communicate by sharing memory; instead, share
memory by communicating” - Effective Go
• Go provides the components to work in an actor style
• No framework - just type in a few lines
• Departs from Actor theory in a few ways
• In use in production for two years
- http://github.com/weaveworks/mesh

25. Thank You
Gopher images by Renee French http://reneefrench.blogspot.com/