Akka - A Brief Intro
3 likes1,932 views
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.
![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”](https://image.slidesharecdn.com/akka-scalainterestgrouptalk-150321164610-conversion-gate01/85/Akka-A-Brief-Intro-7-320.jpg)
![Message protocols
trait Response
case class Success(res: Array[Byte]) extends Response
case class Failure(err: String) extends Response](https://image.slidesharecdn.com/akka-scalainterestgrouptalk-150321164610-conversion-gate01/85/Akka-A-Brief-Intro-11-320.jpg)
![Actor System
system.actorOf(Props[A], name = “A”)](https://image.slidesharecdn.com/akka-scalainterestgrouptalk-150321164610-conversion-gate01/85/Akka-A-Brief-Intro-13-320.jpg)
![Actor System
context.actorOf(Props[C], name = “C”)](https://image.slidesharecdn.com/akka-scalainterestgrouptalk-150321164610-conversion-gate01/85/Akka-A-Brief-Intro-14-320.jpg)
Akka - A Brief Intro
- 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!