The actor model provides simple concurrency, resiliency, and elasticity through processing messages sequentially between actors that have no shared state. Actors receive and respond to messages to define their behavior, and can create other actors within the actor system. Key aspects include that actors are not threads, messages are processed sequentially, multiple actors can work concurrently, and exception handling is done through hierarchical supervisor strategies.

1. & the actor model

2. What is Akka?
A toolkit that provides:
simple concurrency
resiliency
elasticity
high performance

3. What is an actor?
Receive and send messages
Define behavior for
next message
Create other actors

4. The Actor model of computation
processing - behavior
storage - state model
I/O - messages

5. Key things to understand
messages processed sequentially
multiple actors can be working at the same time
actors are not threads
an actor can block (but should minimize it)
no shared state

6. A very simple actor
class MyActor extends Actor with ActorLogging {
def receive = {
case msg ⇒
log.info(“Received: {}”, msg)
}
}

7. Creating actors in an actor system
Everything begins here:
val system = ActorSystem("example")
val myActor = system.actorOf(Props[MyActor],
name = “myActor”)
myActor ! “a boring message”

8. Messages
Can be any object
Should be immutable
Should be serializable
Ideally define a protocol for communication

9. Protocol
“a system of rules that explain the
correct conduct and procedures to
be followed in formal situations”
— Merriam-Webster

10. Message protocols
Define the interaction between actors
Specify clear boundaries
Encode success and failure clearly

11. Message protocols
trait Response
case class Success(res: Array[Byte]) extends Response
case class Failure(err: String) extends Response

12. Actor System

13. Actor System
system.actorOf(Props[A], name = “A”)

14. Actor System
context.actorOf(Props[C], name = “C”)

15. Actor System
A is now the supervisor for D

16. Actor System
An exception occurs in D

17. Actor System
A declares a ‘Restart’ for the given exception.

18. Actor System
override val supervisorStrategy =
OneForOneStrategy(maxNrOfRetries = 10,
withinTimeRange = 1 minute) {
case _: SomeException ⇒ Restart
case _: Exception ⇒ Escalate
}

19. Actor System

20. Extras
● Supervisors
○ provide exception handling
○ “let it crash”
○ orthogonal to actor behavior
● Location transparency
○ abstracts the idea of “where” an actor lives

21. Extras
● Mailboxes
● Routing
○ e.g., round-robin, smallest mailbox, etc.
● Dispatching
○ essentially how to allocate thread resources

22. Thank you!