Concurrency in Scala - the Akka way
Download as PPTX, PDF0 likes3,592 views
This document discusses using Akka and actors for building scalable and concurrent applications in Scala. It introduces actors as fundamental units of computation that communicate asynchronously via message passing. Akka provides tools for creating actor systems and hierarchies. The document uses a monitoring application called Scotchdog as an example, with actors to represent services that are monitored by a watchdog actor. It describes how messages are used to start, stop and check services, and how the watchdog can aggregate status from child actors. The document also briefly mentions using Akka's scheduler and finite state machines to implement more complex actor behaviors.
![CREATING ACTORS
• class Watchdog extends Actor …
• val system = ActorSystem(“Scotchdog”)
• val watchdog = system.actorOf(
Props[Watchdog], name = “watchdog”)
• watchdog is an ActorRef
• we used default constructor
• Props allows customizations of actor
behavior, such as the dispatcher (execution
strategy). We used the default one](https://image.slidesharecdn.com/devconil-130218053835-phpapp02/85/Concurrency-in-Scala-the-Akka-way-19-320.jpg)
![FUTURES
val future = watchdog ?
PerServiceCommand(“myserver", IsStarted)
There are several ways to obtain the value:
• val result = Await.result(future, 5 seconds).
asInstanceOf[Boolean]
• future onComplete {
case Success(value: Boolean) => …
case Failure(_) => …
}](https://image.slidesharecdn.com/devconil-130218053835-phpapp02/85/Concurrency-in-Scala-the-Akka-way-22-320.jpg)
![MORE ADVANCED EXAMPLE
• We want the watchdog to return a combined
status of all services – “up” if all services are
up, otherwise “down”
• We will define:
val services =
new scala.collection.mutable.HashSet[String]
within Watchdog class
• It is safe to have mutable state within an actor!
• When adding services: services += config.name](https://image.slidesharecdn.com/devconil-130218053835-phpapp02/85/Concurrency-in-Scala-the-Akka-way-23-320.jpg)
![MORE ADVANCED EXAMPLE
def receive = {
case Status => {
val responses =
for (child <- services;
serviceActor = context.actorFor(child));
future = serviceActor ? IsStarted)
yield future.asInstanceOf[Future[Boolean]]
sender ! Future.reduce(responses)(_ && _)
}
…](https://image.slidesharecdn.com/devconil-130218053835-phpapp02/85/Concurrency-in-Scala-the-Akka-way-24-320.jpg)
![SCHEDULER EXAMPLE
class ServiceMonitor(config: ServiceConfig) extends Actor with ActorLogging {
var status = false
var polling: Option[Cancellable] = None
def receive = {
case IsStarted => sender ! status
case Monitor =>
polling = Some(scheduler.schedule(Duration.Zero, config.interval, self, Tick))
case Tick =>
sender ? config.isStarted onSuccess { case res: Boolean => status = res }
case UnMonitor => polling.foreach(_.cancel)
…](https://image.slidesharecdn.com/devconil-130218053835-phpapp02/85/Concurrency-in-Scala-the-Akka-way-26-320.jpg)
Concurrency in Scala - the Akka way
- 1. CONCURRENCY IN SCALA THE AKKA WAY Yardena Meymann Sr. Software Architect at VMware February 2013
- 2. SCALABILITY • The amount of work grows – BIG.*
- 3. SCALABILITY • Scale up and out without breaking down
- 4. SCALA • Programming language for JVM • Functional and Object-Oriented • Type-safe • Powerful • Concise • Extensible • Interoperable with Java
- 5. AKKA • Akka is a toolkit and runtime for building highly concurrent, distributed, and fault tolerant event-driven applications on the JVM • Provides unified programming model for concurrency, distribution and fault-tolerance
- 6. ACTORS Actor is a fundamental unit of computation (Carl Hewitt 1973) • Local state, isolated from the world • Sends messages to other actors • Reacts to received messages • Actors usually come in systems
- 7. ACTORS • Elastic – grow and shrink on demand • Lightweight (2.7 M per GB RAM) • Hot deploy – change behavior at runtime • Local or distributed
- 8. EXAMPLE - SCOTCHDOG • Inspired by Monit http://mmonit.com/monit/ • Cross-platform, JVM-based (Scala+Akka) • Configured with list of services • Starts and stops services • Ensures that monitored services are up: checks periodically and starts if necessary
- 9. HOW IS THIS GOING TO WORK • Actor per service • Actor for the watchdog
- 10. ACTOR HIERARCHY Watchdog Service 1 Service 2 Service 3
- 11. AKKA ACTOR HIERARCHY root system user Watchdog system actors Service 1 Service 2 Service 3
- 12. WHY THE HIERARCHY IS IMPORTANT • Fault-tolerance • “Let it crash” • Supervisor can resume, restart, terminate the subordinate; it can also escalate the failure • One-for-one and one-for-all strategies
- 13. LET’S START WITH MESSAGES • Service commands • start • stop • is started? • monitor/unmonitor • Watchdog commands • start • add service • do *** to a specified service • …
- 14. SERVICE COMMANDS sealed trait ServiceCommand case object Start extends ServiceCommand case object Stop extends ServiceCommand case object IsStarted extends ServiceCommand … • Commands need to be immutable objects • Case classes and objects make excellent messages
- 15. WATCHDOG COMMANDS case object StartWatching case class AddService(config: ServiceConfig) case class PerServiceCommand( service: String, command: ServiceCommand) ...
- 16. SENDING MESSAGES • tell (a.k.a bang, or ! operator) sends a message asynchronously and return immediately service ! Start • ask (a.k.a ? operator) sends a message asynchronously and returns a Future representing a possible reply service ? IsStarted
- 17. HANDLING MESSAGES • Define actor class class Service(config: ServiceConfig) extends Actor … • Actor gives us • ability to create other actors • access to self • access to sender of last message • lifecycle hooks
- 18. HANDLING MESSAGES Define receive method within Actor class def receive = { case Start => //perform start action case Stop => //perform stop action case IsStarted => { //call isStarted action and capture the result sender ! result //reply - return the result to sender } } Heavily uses Scala’s pattern matching
- 19. CREATING ACTORS • class Watchdog extends Actor … • val system = ActorSystem(“Scotchdog”) • val watchdog = system.actorOf( Props[Watchdog], name = “watchdog”) • watchdog is an ActorRef • we used default constructor • Props allows customizations of actor behavior, such as the dispatcher (execution strategy). We used the default one
- 20. HANDLING MESSAGES - WATCHDOG def receive = { case AddService(config) => { val service = context.actorOf(Props(new Service(config)), config.name) service ! Monitor } case PerServiceCommand(service, command) => context.actorFor(service) forward command …
- 21. ACTOR REFERENCES • Top level actors are created with system, child actors are created with parent actor’s context • Existing actors can be found with context/system actorFor • ActorRef can be sent to another actor
- 22. FUTURES val future = watchdog ? PerServiceCommand(“myserver", IsStarted) There are several ways to obtain the value: • val result = Await.result(future, 5 seconds). asInstanceOf[Boolean] • future onComplete { case Success(value: Boolean) => … case Failure(_) => … }
- 23. MORE ADVANCED EXAMPLE • We want the watchdog to return a combined status of all services – “up” if all services are up, otherwise “down” • We will define: val services = new scala.collection.mutable.HashSet[String] within Watchdog class • It is safe to have mutable state within an actor! • When adding services: services += config.name
- 24. MORE ADVANCED EXAMPLE def receive = { case Status => { val responses = for (child <- services; serviceActor = context.actorFor(child)); future = serviceActor ? IsStarted) yield future.asInstanceOf[Future[Boolean]] sender ! Future.reduce(responses)(_ && _) } …
- 25. SCHEDULER • We want to check periodically if a service is up, and report the status at any time • For this purpose we can use Akka’s built-in scheduler • …
- 26. SCHEDULER EXAMPLE class ServiceMonitor(config: ServiceConfig) extends Actor with ActorLogging { var status = false var polling: Option[Cancellable] = None def receive = { case IsStarted => sender ! status case Monitor => polling = Some(scheduler.schedule(Duration.Zero, config.interval, self, Tick)) case Tick => sender ? config.isStarted onSuccess { case res: Boolean => status = res } case UnMonitor => polling.foreach(_.cancel) …
- 27. FURTHER IMPROVEMENTS • In practice, the service actor is more complex: for example, we don’t want to start a service again if it is already started or is starting up now • To address this we use Akka’s Finite State Machine actors, a.k.a FSM • This is a topic for a longer talk, so for now…
- 28. CONCLUSIONS • Akka makes concurrency (and distribution, which we didn’t cover) easier • Programming with actors require a paradigm shift, may be challenging at first, but worth it • There is more to Akka then we’ve covered • If you like Akka, but want to program in Java, you can use Java API • Akka integrates with tools like Spring, Apache Camel and ZeroMQ
- 29. RESOURCES • http://www.scala-lang.org • http://akka.io • http://typesafe.com • http://letitcrash.com • http://www.manning.com/roestenburg/ • http://www.cakesolutions.net/teamblogs/2012/07/03/ akka-patterns/ • Coming soon https://github.com/yardena/scotchdog
- 30. THANK YOU