Akka Actors And Futures

Meetu MaltiarPrincipal Consultant

Email: meetu@knoldus.comTwitter:@meetumaltiar

Akka 2.0

Akka name comes from Sami mythology is actually name of a goddess of wisdom and beauty.

Akka incidentally means sister in Telugu!!

The Problem

It is way too hard to build

=> correct highly concurrent systems

=> truly scalable systems

=> self-healing, fault-tolerant systems

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 for load

Introducing Actors

Actor is an entity encapsulating behavior, state and a mailbox to receive messages

For a message received by Actor a thread is allocated to it

Then Actors behavior is applied to the message and potentially some state is changed or messages is passed to other Actors

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 thread is deallocated from the actor. It can be reallocated a thread at a later time

Create Application

import akka.actor.ActorSystem

val system = ActorSystem("firstApp")

My First Actorimport akka.actor.{ Actor, Props }

class MyFirstActor extends Actor { def receive = { case msg => println("Hello!!") }}

Create Actors

MyFirstActor is an ActorRefCreate a top level actor

import akka.actor.{ ActorSystem, Props }

val system = ActorSystem("firstApp")val myFirstActor = system.actorOf(Props[MyFirstActor])

Stop Actors

Also stops all actors in hierarchy

system stop myFirstActor

Send: !

fire-forget

myFirstActor ! “Hello”

Ask: ?

Returns a Future[Any]

import akka.pattern.ask

implicit val timeout = Timeout(50000 milliseconds)

val future = myActor ? "hello"

Await.result(future, timeout.duration).asInstanceOf[Int]

Replyimport akka.actor.Actor

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

Routers

RoundRobin

Random

SmallestMailBox

BroadCast

ScatterGatherFirstCompleted

Routers...

val router = system.actorOf(Props[RouterWorkerActor].withRouter(RoundRobinRouter(nrOfInstances = 5)))

Actor Path

val actorRef = system.actorFor("akka://actorPathApp/user/parent/child")

val parent = context.actorFor("..")

val sibling = context.actorFor("../sibling")

val refPath = actorRef.path

Akka FuturesA Future is a data structure

Used to retrieve of some concurrent operation

This operation is performed by an Actor or a dispatcher directly

The result can be accessed synchronously or asynchronously

Execution Context

Futures need ExecutionContext to execute callback and operations

If we have ActorSystem in scope Future will use default dispatcher as ExecutionContext

We can use factory methods provided by ExecutionContext companion object to wrap Executors and ExecutorServices

Use With Actors

There are two ways to get a reply from an Actor. First one is (myActor ! Msg)

The second way is through a Future. Using Actors “?” method will return a Future

The simplest way to use Await method call, though not recommended as the thread blocks till result is obtained.

Future With Akka andAwait

import akka.actor._import akka.pattern.askimport akka.util.duration._import akka.util.Timeoutimport akka.dispatch.Await

object FutureWithAwaitApp extends App { implicit val timeout = Timeout(50000 milliseconds) val system = ActorSystem("future") val echoActor = system.actorOf(Props[EchoActor]) val future = echoActor ? "Hello World" val result = Await.result(future, timeout.duration).asInstanceOf[String] println(result)}

Use Futures Directly

import akka.dispatch._import akka.util.duration._import akka.actor.ActorSystem

object MonadicFutureApplication extends App { implicit val system = ActorSystem("future")

val f1 = Future { "Hello" + "World" } val f2 = f1 map { x => x.length } val result = Await.result(f2, 1 second) println(result)}

Composing Futuresobject MultiMonadicFutureApplication extends App { implicit val system = ActorSystem("future")

val f1 = Future { "Hello" + "World" } val f2 = Future { 3 } val f3 = f1 flatMap { x => f2 map { y => x.length * y } }

val result = Await.result(f3, 1 second)}

Code Samples

https://github.com/meetumaltiar/AkkaKnolX

References

Viktor Klang talk on Akka 2.0 at NE Scala symposium

Akka website akka.io