Simpler Concurrency, Scalability & Fault-tolerance through ...days2011.scala-lang.org/node/138/162/16-2-M - Akka - Bonér.pdf · Akka: Simpler Concurrency, Scalability & Fault-tolerance

Akka:Simpler Concurrency, Scalability &

Fault-tolerance through Actors

Jonas Bonér

Viktor Klang

Tuesday, April 20, 2010

•Writing correct concurrent applications is too hard

•Scaling out applications is too hard

•Writing highly fault-tolerant applications is too hard

We believe that...

It doesn’t have to be like this

We need to raise the abstraction level

Locks & Threadsare...

...sometimes

plain evil

...but always the

wrong default

Introducing

Persistent

Distributed

RESTful Secure

Agents

Dataflow Open Source

Actors

Actorsone tool in the toolbox

• Implements Message-Passing Concurrency• Share NOTHING• Isolated lightweight processes•Communicates through messages•Asynchronous and non-blocking• Each actor has a mailbox (message queue)

Actor Model of Concurrency

• Easier to reason about• Raised abstraction level• Easier to avoid–Race conditions–Deadlocks–Starvation–Live locks

Akka Actors

Two different models

• Thread-based• Event-based– Very lightweight (600 bytes per actor)– Can easily create millions on a single workstation (6.5 million on 4 G RAM)– Does not consume a thread

Microbenchmark

•Chameneos benchmark• http://shootout.alioth.debian.org/

• +4 times faster• Run it yourself (3 different benchmarks):

• http://github.com/jboner/akka-bench

Akka 0.8.1 3815

Scala Actors 2.8.0.Beta1 (react) 16086

caseobjectTick

classCounterextendsActor{privatevarcounter=0

defreceive={caseTick=>counter+=1println(counter)}}

Actors

valworker=actor{caseWork(fn)=>fn()}

Actorsanonymous

//fire‐forgetcounter!Tick

Send: !

//usesFuturewithdefaulttimeoutvalresult:Option[..]=actor!!Message

Send: !!

//returnsafuturevalfuture=actor!!!Messagefuture.awaitvalresult=future.get

...Futures.awaitOne(List(fut1,fut2,...))Futures.awaitAll(List(fut1,fut2,...))

Send: !!!

classSomeActorextendsActor{defreceive={caseUser(name)=>//usereplyreply(“Hi”+name)}}

Akka Dispatchers

classDispatchers{defnewThreadBasedDispatcher(actor:Actor)

defnewExecutorBasedEventDrivenDispatcherdefnewExecutorBasedEventDrivenWorkStealingDispatcher

...//etc}

Dispatchers

classMyActorextendsActor{dispatcher=Dispatchers.newThreadBasedDispatcher(this)...}

actor.dispatcher=dispatcher//beforestarted

Set dispatcher

Let it crash fault-tolerance

Stolen from

ErlangTuesday, April 20, 2010

9 nines

OneForOne fault handling strategy

AllForOnefault handling strategy

Supervisor hierarchies

AllForOneStrategy(maxNrOfRetries,withinTimeRange)

OneForOneStrategy(maxNrOfRetries,withinTimeRange)

Fault handlers

link(actor)unlink(actor)

startLink(actor)spawnLink[MyActor]

Linking

trapExit=List(classOf[ServiceException],classOf[PersistenceException])

trapExit

classSupervisorextendsActor{trapExit=List(classOf[Throwable])faultHandler=Some(OneForOneStrategy(5,5000))

defreceive={caseRegister(actor)=>link(actor)}}

Supervision

classFaultTolerantServiceextendsActor{...overridedefpreRestart(reason:Throwable)={...//cleanupbeforerestart}overridedefpostRestart(reason:Throwable)={...//initafterrestart}}

Manage failure

Remote Actors

//usehost&portinconfigRemoteNode.start

RemoteNode.start("localhost",9999)

Remote Server

Scalable implementation based on NIO (Netty) & Protobuf

•Client-initated and managed•Server-initiated and managed

Two types of

remote actors

//methodsinActorclass

spawnRemote[MyActor](host,port)

spawnLinkRemote[MyActor](host,port)

startLinkRemote(actor,host,port)

Client-managedsupervision works across nodes

valactorProxy=spawnLinkRemote[MyActor](“darkstar”,9999)

actorProxy!message

Client-managedmoves actor to server

client manages through proxy

RemoteNode.register(“service:id”,newMyService)

Server-managedregister and manage actor on server

client gets “dumb” proxy handle

server part

valhandle=RemoteClient.actorFor(“service:id”,“darkstar”,9999)

handle!message

Server-managed

client part

Cluster.relayMessage(classOf[TypeOfActor],message)

for(endpoint<‐Cluster)spawnRemote[TypeOfActor](endpoint.host,endpoint.port)

Cluster Membership

STManother tool in the toolbox

What is STM?

STM: overview• See the memory (heap and stack) as a transactional dataset

• Similar to a database• begin• commit• abort/rollback

• Transactions are retried automatically upon collision

• Rolls back the memory on abort

• Separates Identity from Value- Values are immutable- Identity (Ref) holds Values

•Change is a function•Compare-and-swap (CAS)•Abstraction of time•Must be used within a transaction

Managed References

valref=Ref(Map[String,User]())

valusers=ref.get

valnewUsers=users+(“bill”‐>User(“bill”))

ref.swap(newUsers)

Managed References

valusers=TransactionalMap[String,User]()

valusers=TransactionalVector[User]()

Transactionaldatastructures

importTransaction.Local._

atomic{...atomic{//nestedtransactionscompose...//dosomethingwithinatransaction}}

STM: API

Actors + STM = Transactors

classUserRegistryextendsTransactor{privatelazyvalstorage=TransactionalMap[String,User]()

defreceive={caseNewUser(user)=>storage+(user.name‐>user)...}}

Transactors

TransactorsStart transaction

Send message

Update statewithin transaction

Send message

Transaction fails

Send message

Transaction fails

Transactors

TransactorsTransactionautomatically

retried

Agentsyet another tool in the toolbox

valagent=Agent(5)

//sendfunctionasynchronouslyagentsend(_+1)

valresult=agent()//deref...//useresult

agent.close

Agents

Cooperates with STMTuesday, April 20, 2010

Deploy as dependency JAR in WEB-INF/lib etc. Run as stand-alone microkernel Soon OSGi-enabled, then drop

in any OSGi container (Spring DM server, Karaf etc.)

How to run it?

Akka Persistence

Persistence//transactionalCassandra‐backedMapvalmap=CassandraStorage.newMap

//transactionalRedis‐backedVectorvalvector=RedisStorage.newVector

//transactionalMongo‐backedRefvalref=MongoStorage.newRef

Security

...and much much more

GuiceAMQP

Spring

Learn morehttp://akkasource.org

The commercialentity behind Akka

http://akkasource.com

EOFTuesday, April 20, 2010

?Tuesday, April 20, 2010

Simpler Concurrency, Scalability & Fault-tolerance through ...days2011.scala-lang.org/node/138/162/16-2-M - Akka - Bonér.pdf · Akka: Simpler Concurrency, Scalability & Fault-tolerance

Documents

Promising-ARM/RISC-V - a simpler and faster operational...

Simpler, Faster, Better: Concurrency Utilities in JDK...

Toward a Generic and Concurrency -Aware Pipes & Filters...

Akka Scala Concurrency

MAKING THINGS SIMPLER -...

Simplifying concurrency: Actors. In particular, AKKA.

FUNCTIONAL PROGRAMMING IN MODERN SOFTWARE SYSTEMS ·...

Map(), flatmap() and reduce() are your new best friends:...

Getting Cozy with Actors - DeveloperMarch...What is Akka?...

Embracing concurrency for fun utility and simpler code

etffm18 Principles Reactive Programming...• Akka actors...

Akka Concurrency - Artima · Excerpt from Akka Concurrency....

Programming Scalable Cloud Services with AEONquential...

Scalable Solutions - Jfokus€¦ · Akka is the platform...

Akka Documentation · 2019-03-28 · Akka Documentation,...

Introducing Akka