Deep Introduction to Akka

akkaIntroducing

Friday, September 30, 2011

DeepIntroduction to Akka

Patrik NordwallTypesafe

Twitter: @patriknw


Vision

Simpler

Concurrency

Scalability

Fault-tolerance


Actors


What is an Actor?


Event-drivenThread

Event-drivenThread

Behavior

State

Actor


case object Tick

class Counter extends Actor { var counter = 0

def receive = { case Tick => counter += 1 println(counter) }}

Actors


val counter = actorOf[Counter].start()

Create Actors

counter is an ActorRefFriday, September 30, 2011

counter ! Tick

Tell: !

fire-forget


// returns a futureval future = counter ? Current

val count: Option[Int] = future.as[Int]

Ask: ?

returns the Future directly


Replyclass Counter extends Actor { var counter = 0

def receive = { case Tick => counter += 1 case Current => self.reply(counter) }}


Future

future.awaitfuture onResult { ... } onException { ... } onTimeout { ... }

val future = Future { "Hello" + "World"}


object Shared { val myDispatcher = Dispatchers .newExecutorBasedEventDrivenDispatcher("my") .setCorePoolSize(7) .build}

class MyActor extends Actor { self.dispatcher = Shared.dispatcher ...}

Set dispatcher


Translation Service with HTTP API- count words: 100 ms- translate text: 100 ms

We have 8 threads

Must handle 4 concurrent request with average response time of <110 ms

Example


Example

Web Frontend

Translation Service

Text Translator

Word Counter

HTTP Req


Source code: https://github.com/patriknw/akka-playground

Example


https://github.com/patriknw/akka-playground

https://github.com/patriknw/akka-playground

Typed Actors


trait Counter { def tick(): Unit def current: Int}

Typed Actors


class CounterImpl extends TypedActor with Counter {

private var counter = 0

def tick() { counter += 1 }

def current = counter}

Typed Actors


val counter = TypedActor.newInstance( classOf[Counter], classOf[CounterImpl]) counter.tick()counter.tick()val cur = counter.current

Typed Actors


Remote Actors


// use host & port in configActor.remote.start()

Actor.remote.start("darkstar", 2552)

Remoting

Scalable implementation based on NIO (Netty) & Protobuf


import Actor._

remote.register(“service:id”, actorOf[MyService])

Server

server partFriday, September 30, 2011

val service = remote.actorFor( “service:id”, “darkstar”, 2552)

service ! message

Client

client part


Problem Deployment (local vs remote) is a dev decision

We get a fixed and hard-coded topology Can’t change it dynamically and adaptively

Needs to be a deployment & runtime decision

Remoting in Akka 1.2


Let it crash fault-tolerance


Fault-tolerant onion-layered Error Kernel


ErrorKernel


link(actor)unlink(actor)

startLink(actor)spawnLink[MyActor]

Linking


AllForOneStrategy( errors, maxNrOfRetries, withinTimeRange)

OneForOneStrategy( errors, maxNrOfRetries, withinTimeRange)

Fault handlers


class MySupervisor extends Actor { faultHandler = AllForOneStrategy( List(classOf[IllegalStateException]) 5, 5000))

def receive = { case Register(actor) => self.link(actor) }}

Supervision


class FaultTolerantService extends Actor { ... override def preRestart(reason: Throwable) = { ... // clean up before restart } override def postRestart(reason: Throwable) = { ... // init after restart }}

Manage failure


AMQP

Dataflow

Security

...and much much more

Async-HTTP

Guice

scalaz

FSMSTM

Spring

Camel

MicrokernelTestkit


Get it and learn morehttp://akka.io


http://jonasboner.com/

http://jonasboner.com/

EOFFriday, September 30, 2011

Deep Introduction to Akka

Technology

Transcript of Deep Introduction to Akka