Introduction to Akka 2.0 and how we used Akka to to build a massively scalable application which is processing north of 50 million feeds.

1. Achieving massive scalability
with Akka
Vikas Hazrati @

2. about
CTO at Knoldus Software
Co­Founder at MyCellWasStolen.com
Community Editor at InfoQ.com
Dabbling with Scala – last 40 months
Enterprise grade implementations on Scala
– 18 months
2

3. akka
A actor­based concurrency framework
Provides solutions for non blocking
concurrency
Written in Scala, also works in Java
Open source
Now at version 2.0.2
Lead developer and founder: Jonas Boner
JRockit, AspectWerkz, AspectJ, Terracotta

4. what?
Platform for next generation, event
driven, scalable and fault tolerant
architectures on the JVM.

5. why akka
simpler concurrency
event driven
scale up or scale out
fault tolerance
location transparency / remoting
scala and java api

6. how to use
As a jar in your WEB­INF/lib
As a microkernel and drop
your application in it

7. aha actors
message­Passing Concurrency
share NOTHING
isolated lightweight processes
communicates through messages
asynchronous and non­blocking

8. actors
defined in the 1973 paper by Carl Hewitt
popularized by Erlang
alleviates the dev
from explicit locking
and thread management
easy to write concurrent and parallel
systems
actors like objects BUT dont share state

10. actor system
envision breaking
task into subtasks

11. actor system
each actor has one
supervisor
Nice co workers, dont bother others
Do not block (external interaction)
Do not pass mutable objects

12. mutability, aah!
scala> var sum =0
sum: Int = 0
scala> val list = (1 to 1000).toList.par
scala> list.foreach(sum += _); sum
res7: Int = 452474
scala> var sum =0
sum: Int = 0
scala> list.foreach(sum += _); sum
res8: Int = 497761
scala> var sum =0
sum: Int = 0
scala> list.foreach(sum += _); sum
res9: Int = 422508

13. actor
state
freely passed
behavior
Actor
Location
transparency
mail-box
children
actor reference
supervise
strategy
hides
state

14. defining an actor
import akka.actor.{ Actor, Props }
class MyFirstActor extends Actor {
def receive = {
case msg => println("Hello!!")
}
}

15. create
import akka.actor.{ ActorSystem, Props }
val system = ActorSystem("firstApp")
val myFirstActor =
system.actorOf(Props[MyFirstActor])
MyFirstActor is an ActorRef
Create a top level actor

16. messages
! fire and forget
myFirstActor ! “Hello”
? ask – send and receive future
import akka.pattern.ask
implicit val timeout = Timeout(50000
milliseconds)
val future = myActor ? "hello"
Await.result(future,
timeout.duration).asInstanceOf[Int]

17. reply
import akka.actor.Actor
class LongWorkingActor extends Actor {
def receive = {
case number: Int =>
sender ! (“Hi I received ” + number)
}
}

18. stop
system stop myFirstActor

19. routers
RoundRobin
Random
SmallestMailBox
BroadCast
...
val router =
system.actorOf(
Props[RouterWorkerActor].
withRouter(RoundRobinRouter(nrOfInstances =
5)))

20. fault tolerance
let it crash
linked set of actors

21. all for one

22. one for one

23. supervisor strategy
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
}
}

24. supervisor hierarchies

25. other concepts
Akka STM
Remote Actors
Akka Serialization
Persistence

26. problem statement

27. considerations

28. hmm...
STM – X
Serialization – X
Persistence – X
Remoting – ?/X

32. dispatchers
Event based dispatcher
PinnedDispatcher
BalancingDispatcher
Calling ThreadDispatcher

34. ala carte'

35. used in ...

36. more information
http://akka.io
http://blog.knoldus.com/tag/akka/
vikas@knoldus.com
https://github.com/knoldus/AkkaKnolX

37. Everyone ! “Thanks”