Successfully reported this slideshow.
Introducing Akka
Meetu Maltiar
Cisco
blog: meetumaltiar.wordpress.com
twitter: @meetumaltiar
28th June 2014
Agenda
History of Akka
Scala basics
The use case of Akka
Akka Actors
Akka Supervision
History
Philipp Haller worked on Actor model and released it in Scala 2.1.7 in July 2006
Jonas Boner created Akka to bring...
Akka Who Uses It
Scala Basics
Scala is a JVM based strongly typed language
Scala is hybrid: Functional as well as Object-Oriented
Scala is ...
Scala Compared To Java
Scala adds Scala removes
pure object system static members
operator overloading primitive types
clo...
Scala Cheat Sheet(1) definitions
Scala method definitions
!
def fun(x: Int) = {
result
}
!
def fun = result
!
Scala variable...
Scala Cheat Sheet(2) definitions
Scala class and object
!
class Sample(x: Int, p: Int) {
def instMeth(y: Int): Int = x + y
...
Scala: Pattern Matching
All that is required to add a case keyword to each class that is to be pattern matchable
!
Pattern...
Akka
The name comes from a goddess in Sami mythology that
represented all wisdom and beauty in the world
It is also the na...
The Problem
It is way to hard to build
=> correct highly concurrent systems
=> Truly scalable systems
=> self-healing, fau...
What is Akka?
Right abstraction with actors for concurrent, fault-tolerant and
scalable applications
For Fault-Tolerance u...
Right Abstraction
Never think in terms of shared state, state visibility, threads, locks,
concurrent collections, thread n...
Actor Model
Actor Model (1973): Carl Hewitt’s definition
!
The fundamental unit of computation that embodies:
- Processing
...
Introducing Actors
Actor is an entity encapsulating behaviour, state and a mailbox
to receive messages
For a message recei...
Introducing Actors..
There is elasticity between message processing and addition of
new messages.
New messages can be adde...
Mailbox
Actor having behaviour, state and a mailbox
Messages are in mailbox
No thread is allocated to the Actor
Thread is allocated to the Actor
It is now ready to read message and apply behaviour
Mailbox
Thread is allocated to the Actor
It has read message and is applying behaviour
Mailbox
Mailbox
Actor has handled message
Thread is deallocated
It will be allocated a thread later
Create Actor System
ActorSystem is a heavy-weight structure that will allocate 1…n threads. So,create one
per logical appl...
My First Actor
import akka.actor._	
!
class MyFirstActor extends Actor {	
def receive = {	
case msg: String => println(msg...
Create Actor
package com.meetu.akka	
!
import akka.actor._	
!
object HelloWorldAkkaApplication extends App {	
val system =...
Create Actor
when actorOf is called path is reserved
!
A random UID is assigned to incarnation
!
Actor instance is created...
Send Message
package com.meetu.akka	
!
import akka.actor._	
!
object HelloWorldAkkaApplication extends App {	
val system =...
Ask Pattern
package com.meetu.akka	
!
import akka.actor._	
import akka.pattern.ask	
import akka.util.Timeout	
import scala...
Reply From Actor
import akka.actor.Actor	
!
class LongWorkingActor extends Actor {	
def receive = {	
case number: Int =>	
...
Routers
RoundRobin
!
Random
!
SmallestMailBox
!
Broadcast
!
ScatterGatherFirstCompleted
Round Robin Router
import akka.actor._	
import akka.routing.RoundRobinPool	
import akka.routing.Broadcast	
!
object Router...
Failure: Typical Scenario
There is a single thread of control
!
If this Thread goes in failure we are doomed
!
We therefor...
Supervision
Supervise means manage another Actor failures
!
Error handling in Actors is handled by letting Actors monitor ...
…Let’s take a
standard OO
application
Which components have
critically important state
and
Explicit error handling
Supervise Actor
Every Actor exists in a Tree topology. Its parent provide
automatic supervision
!
Every Actor has a defaul...
Supervision Actor
class Supervisor extends Actor {	
override val supervisorStrategy = 	
OneForOneStrategy(maxNrOfRetries =...
Supervision: Child Actor
class Child extends Actor {	
var state = 0	
def receive = {	
case ex: Exception => throw ex	
case...
Supervision Application
object SupervisionExampleApp extends App {	
implicit val timeout = Timeout(50000 milliseconds)	
va...
Running Supervision Application
Learning
Resources
Code examples at Github	
https://github.com/meetumaltiar/AkkaQuickStart	
!
Akka Documentation	
http://a...
Thank You!!
Introducing Akka
Introducing Akka
Introducing Akka
Introducing Akka
Introducing Akka
Upcoming SlideShare
Loading in …5
×

Introducing Akka

1,900 views

Published on

Presented at Bangalore Java User Group on "Introducing Akka" on 28th June 2014

Published in: Engineering, Technology
  • Be the first to comment

Introducing Akka

  1. 1. Introducing Akka Meetu Maltiar Cisco blog: meetumaltiar.wordpress.com twitter: @meetumaltiar 28th June 2014
  2. 2. Agenda History of Akka Scala basics The use case of Akka Akka Actors Akka Supervision
  3. 3. History Philipp Haller worked on Actor model and released it in Scala 2.1.7 in July 2006 Jonas Boner created Akka to bring highly concurrent, event driven to JVM Inspired by Erlang Actors, Jonas Boner began working on Akka early 2009 Jonas Boner as part of Scalable Solutions releases Akka version 0.5 in January 2010 Akka is now part of Typesafe Platform together with Play framework and Scala language
  4. 4. Akka Who Uses It
  5. 5. Scala Basics Scala is a JVM based strongly typed language Scala is hybrid: Functional as well as Object-Oriented Scala is compatible with Java Scala has support for currying, pattern matching, ADT’s, lazy evaluation, tail recursion etc Scala is compiled to Java byte-codes and run on Java Virtual Machine
  6. 6. Scala Compared To Java Scala adds Scala removes pure object system static members operator overloading primitive types closures break and continue mixin composition with traits special treatment of interfaces existential types wildcards abstract types raw types pattern matching enums
  7. 7. Scala Cheat Sheet(1) definitions Scala method definitions ! def fun(x: Int) = { result } ! def fun = result ! Scala variable definitions ! var x: Int = expression val x: String = expression Java method definitions ! Int fun(int x) { return result } ! (no parameterless methods) ! java variable definitions ! Int x = expression final String x = expression
  8. 8. Scala Cheat Sheet(2) definitions Scala class and object ! class Sample(x: Int, p: Int) { def instMeth(y: Int): Int = x + y } ! object Sample { def staticMeth(x: Int, y: Int): Int = x * y } ! ! ! ! ! ! ! ! ! Java class ! class Sample { private final int x; public final int p; ! Sample(int x, int p) { this.x = x; this.p = p; } ! int instMeth(int y) { return x + y; } ! static int staticMeth(int x, int y) { return x *y; } }
  9. 9. Scala: Pattern Matching All that is required to add a case keyword to each class that is to be pattern matchable ! Pattern match also returns a value ! Similar to switch except that Scala compares objects as expressions. Only one matcher is executed at a time. ! case class Employee(name: String) val employee = Employee(“john”) employee match { case Employee(“john”) => “Hello John!” case _ => “Hello there!” } ! res0: String = Hello John
  10. 10. Akka The name comes from a goddess in Sami mythology that represented all wisdom and beauty in the world It is also the name of a beautiful mountain in Laponia in north part of Sweden Incidentally in India it means sister in Telugu!!
  11. 11. The Problem It is way to hard to build => correct highly concurrent systems => Truly scalable systems => self-healing, fault-tolerant systems
  12. 12. What is Akka? Right abstraction with actors for concurrent, fault-tolerant and scalable applications For Fault-Tolerance uses “Let It Crash” model Abstraction for transparent distribution of load We can Scale In and Scale Out
  13. 13. Right Abstraction Never think in terms of shared state, state visibility, threads, locks, concurrent collections, thread notification etc Low level concurrency becomes Simple Workflow - we only think in terms of message flows in system We get high CPU utilisation, low latency, high throughput and scalability - for free as part of this model Proven and superior model for detecting and recovering from errors
  14. 14. Actor Model Actor Model (1973): Carl Hewitt’s definition ! The fundamental unit of computation that embodies: - Processing - Storage - Communication ! Three Axioms - Create new Actors - Send messages to Actor it knows - Designate how it should handle the next message it receives
  15. 15. Introducing Actors Actor is an entity encapsulating behaviour, state and a mailbox to receive messages For a message received by Actor a thread is allocated to it Then behaviour is applied to the message and potentially some state is changed or messages are passed to other Actors
  16. 16. Introducing Actors.. There is elasticity between message processing and addition of new messages. New messages can be added while Actor execution is happening. When processing of messages is completed; the thread is deallocated from the Actor. It can again be reallocated a thread at a later time.
  17. 17. Mailbox Actor having behaviour, state and a mailbox Messages are in mailbox No thread is allocated to the Actor
  18. 18. Thread is allocated to the Actor It is now ready to read message and apply behaviour Mailbox
  19. 19. Thread is allocated to the Actor It has read message and is applying behaviour Mailbox
  20. 20. Mailbox Actor has handled message Thread is deallocated It will be allocated a thread later
  21. 21. Create Actor System ActorSystem is a heavy-weight structure that will allocate 1…n threads. So,create one per logical application ! Top level actors are created from an ActorSystem ! This is so because first Actor is the child from ActorSystem. If we create another Actor from this first Actor: then second Actor will be child of the first Actor ! We therefore get a tree like structure and hence get automatic supervision ! val system = ActorSystem("myfirstApp")
  22. 22. My First Actor import akka.actor._ ! class MyFirstActor extends Actor { def receive = { case msg: String => println(msg) case _ => println("default") } } you extend an Actor ! receive method reads the message from mailbox ! receive is a partially applied function ! pattern match is applied on the message
  23. 23. Create Actor package com.meetu.akka ! import akka.actor._ ! object HelloWorldAkkaApplication extends App { val system = ActorSystem("myfirstApp") val myFirstActor: ActorRef = system.actorOf(Props[MyFirstActor]) …….. } Create an Actor System ! create actor from Actor System using actorOf method ! the actorOf method returns an ActorRef instead of Actor class type
  24. 24. Create Actor when actorOf is called path is reserved ! A random UID is assigned to incarnation ! Actor instance is created ! preStart is called on instance
  25. 25. Send Message package com.meetu.akka ! import akka.actor._ ! object HelloWorldAkkaApplication extends App { val system = ActorSystem("myfirstApp") val myFirstActor: ActorRef = system.actorOf(Props[MyFirstActor]) myFirstActor ! "Hello World" myFirstActor.!("Hello World") } Scala version has a method named “!” ! This is asynchronous thread of execution continues after sending ! It accepts Any as a parameter ! In Scala we can skip a dot with a space: So it feels natural to use
  26. 26. Ask Pattern package com.meetu.akka ! import akka.actor._ import akka.pattern.ask import akka.util.Timeout import scala.concurrent.duration._ import scala.concurrent.Await import scala.concurrent.Future ! object AskPatternApp extends App { implicit val timeout = Timeout(500 millis) val system = ActorSystem("BlockingApp") val echoActor = system.actorOf(Props[EchoActor]) ! val future: Future[Any] = echoActor ? "Hello" val message = Await.result(future, timeout.duration).asInstanceOf[String] ! println(message) } ! class EchoActor extends Actor { def receive = { case msg => sender ! msg } } Ask pattern is blocking ! Thread of execution waits till response is reached
  27. 27. Reply From Actor import akka.actor.Actor ! class LongWorkingActor extends Actor { def receive = { case number: Int => sender ! ("Hi I received the " + number) } } Each Actor has been provided default sender ! Use “!” method to send back the message
  28. 28. Routers RoundRobin ! Random ! SmallestMailBox ! Broadcast ! ScatterGatherFirstCompleted
  29. 29. Round Robin Router import akka.actor._ import akka.routing.RoundRobinPool import akka.routing.Broadcast ! object RouterApp extends App { val system = ActorSystem("routerApp") val router = system.actorOf(RoundRobinPool(5).props(Props[RouterWorkerActor]), "workers") router ! Broadcast("Hello") } ! class RouterWorkerActor extends Actor { def receive = { case msg => println(s"Message: $msg received in ${self.path}") } } A router sits on top of routees ! When messages are sent to Router, Routees get messages in Round Robin
  30. 30. Failure: Typical Scenario There is a single thread of control ! If this Thread goes in failure we are doomed ! We therefore do explicit error handling on this thread ! Worse error do not propagate between threads. There is no way of knowing that something failed ! We therefore do defensive programming with: • Error handling tangled with business logic • Scattered all over code base ! We can do better than this
  31. 31. Supervision Supervise means manage another Actor failures ! Error handling in Actors is handled by letting Actors monitor (supervise) each other of failure ! This means if Actor crashes a notification is sent to its supervisor (an Actor), who can react to failure ! This provides clean separation of processing and error handling
  32. 32. …Let’s take a standard OO application
  33. 33. Which components have critically important state and Explicit error handling
  34. 34. Supervise Actor Every Actor exists in a Tree topology. Its parent provide automatic supervision ! Every Actor has a default Supervision strategy, which is usually sufficient ! supervision strategy can be overridden ! We have either One for One strategy. Here only the Actor that crashed is handled. ! Other one is All For One strategy. Here all children are restarted
  35. 35. Supervision Actor class Supervisor extends Actor { override val supervisorStrategy = OneForOneStrategy(maxNrOfRetries = 10, withinTimeRange = 1 minute) { case _: ArithmeticException => Resume case _: NullPointerException => Restart case _: IllegalArgumentException => Stop case _: Exception => Escalate } ! def receive = { case p: Props => sender ! context.actorOf(p) } }
  36. 36. Supervision: Child Actor class Child extends Actor { var state = 0 def receive = { case ex: Exception => throw ex case x: Int => state = x case "get" => sender ! state } }
  37. 37. Supervision Application object SupervisionExampleApp extends App { implicit val timeout = Timeout(50000 milliseconds) val system = ActorSystem("supervisionExample") val supervisor = system.actorOf(Props[Supervisor], "supervisor") val future = supervisor ? Props[Child] val child = Await.result(future, timeout.duration).asInstanceOf[ActorRef] child ! 42 println("Normal response " + Await.result(child ? "get", timeout.duration).asInstanceOf[Int]) child ! new ArithmeticException println("Arithmetic Exception response " + Await.result(child ? "get", timeout.duration).asInstanceOf[Int]) child ! new NullPointerException println("Null Pointer response " + Await.result(child ? "get", timeout.duration).asInstanceOf[Int]) }
  38. 38. Running Supervision Application
  39. 39. Learning Resources Code examples at Github https://github.com/meetumaltiar/AkkaQuickStart ! Akka Documentation http://akka.io/docs/ ! Scala Documentation http://www.scala-lang.org/documentation/
  40. 40. Thank You!!

×