Simpler Concurrency, Scalability & Fault-tolerance through …assets.en.oreilly.com/1/event/45/Akka_...

Akka:Simpler Concurrency, Scalability &

Fault-tolerance through Actors

Jonas Bonér@jboner

Tuesday, July 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 & Threads

are...

...sometimes

plain evil

...but always the

wrong default

“Threads are to Concurrency as Witchcraft is to Physics”

“Hanging by a thread is the punishment for Shared State Concurrency”

- Gilad Bracha

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

Introducing

Persistent

Distributed

RESTful Secure

Agents

Dataflow Open Source

Actors

ARCHITECTURE

SERVICES

ARCHITECTURE

ADD-ON

MODULES

ARCHITECTURE

ENTERPRISE

MODULES

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

!"#$%&'($!)!"#$%

!*"##!&'()*+,!$+)$,-#!-$*',!.

!!./01")$!1"/!$'()*+,!/!0

!!-$2!,+$+#1+!/!.

!!!!!"#$!"#$%!/2!

!!!!!!$'()*+,!3/!4

!!!!!!5,#)*6)7$'()*+,8

Actors

03.&/)!-$*',:;

1"*!$'()*+,!/!<$*',=>?&'()*+,@

Create Actors

$'()*+, is an -$*',A+>

1"*!<$*',!/!<$*',=>7,$4!BC-$*',7::88

Create Actors

create actor with constructor arguments

1"*!$'()*+,!/!<$*',=>?&'()*+,@

$'()*+,:D*<,*

Start actors

1"*!$'()*+,!/!<$*',=>?&'()*+,@:D*<,*

Start actors

1"*!$'()*+,!/!<$*',=>?&'()*+,@:D*<,*

$'()*+,:D*'5

Stop actors

!*"##%BC-$*',!$+)$,-#!-$*',!.

%%&1$//0-$%-$2!#)#*!/!.

!!!!:::!EE!$<66+F!<>*+,!GD*<,*H!

!!&1$//0-$%-$2!DI(*F'J)!/!.

!!!!:::!EE!$<66+F!K+>',+!GD*'5H

init & shutdown callbacks

!*"##!A+$(,D#1+-$*',!$+)$,-#!-$*',!.

!!./01")$!1"/!$'()*+,!/!0

!!D+6>:#F!/!LD+,1#$+M,+$(,D#1+N

!!-$2!,+$+#1+!/!.

!!!!!"#$!"#$%!/2!

!!!!!!$'()*+,!3/!4

!!!!!!D+6>!O!"#$%

the self reference

1"*%J',%+,!/!<$*',!.

!!!"#$!P',%7>)8!/2!>)78

Actorsanonymous

$'()*+,!O!"#$%!

Send: !

fire-forget

1"*!,+D(6*!/!7<$*',!OO!B+DD<Q+8:<D?R*,#)Q@

Send: !!

uses Future under the hood (with time-out)

1"*!,+D(6*=5*#')!/!<$*',!OO!B+DD<Q+

1"*!,+D(6*!/!,+D(6*=5*#')

!!!!!!!!!!!!:Q+*=,S6D+7F+><(6*A+D(6*8

1"*!,+D(6*!/!,+D(6*=5*#'):Q+*=,S6D+7

!!!!)5/&4%,$4!ST$+5*#')7L"#U+F!'(*N888

Send: !!

returns an Option[ResultType] directly

EE!,+*(,)D!<!>(*(,+

1"*!>(*(,+!/!<$*',!OOO!B+DD<Q+

>(*(,+:<J<#*

1"*!,+D(6*!/!>(*(,+:Q+*

V(*(,+D:<J<#*=)+7W#D*7>(*4X!>(*YX!:::88

V(*(,+D:<J<#*-667W#D*7>(*4X!>(*YX!:::88

Send: !!!

returns the Future directly

!*"##!R'U+-$*',!$+)$,-#!-$*',!.

!!-$2!,+$+#1+!/!.

!!!!!"#$!ZD+,7)<U+8!/2!

!!!!!!EE!(D+!,+56C

!!!!!!D+6>:,+56C7L[#!N!3!)<U+8

!*"##!R'U+-$*',!$+)$,-#!-$*',!.

!!-$2!,+$+#1+!/!.

!!!!!"#$!ZD+,7)<U+8!/2!

!!!!!!EE!D*',+!<J<C!*I+!D+)F+,

!!!!!!EE!*'!(D+!6<*+,!',!

!!!!!!EE!D'U+JI+,+!+6D+

!!!!!!:::!/!D+6>:D+)F+,

!*"##!R'U+-$*',!$+)$,-#!-$*',!.

!!-$2!,+$+#1+!/!.

!!!!!"#$!ZD+,7)<U+8!/2!

!!!!!!EE!D*',+!<J<C!*I+!D+)F+,!>(*(,+

!!!!!!EE!*'!,+D'61+!6<*+,!',!

!!!!!!EE!D'U+JI+,+!+6D+

!!!!!!:::!/!D+6>:D+)F+,V(*(,+

EE!F+>#)+!*I+!$<D+!$6<DD

!"#$%!*"##!A+Q#D*+,7(D+,M!ZD+,8

EE!$,+<*+!<)F!D+)F!<!)+J!$<D+!$6<DD!U+DD<Q+

<$*',!O!A+Q#D*+,7(D+,8

EE!*(56+D

<$*',!O!7(D+,)<U+X!5<DDJ',F8

EE!6#D*D

<$*',!O!W#D*7LK#66NX!LK'KNX!L<6#$+N8

Good immutable messages

Akka Dispatchers

&'($!)!\#D5<*$I+,D!.

!!-$2!)+JST+$(*',]<D+FS1+)*\,#1+)\#D5<*$I+,7)<U+M!R*,#)Q8

!!-$2!)+JST+$(*',]<D+FS1+)*\,#1+)P',%R*+<6#)Q\#D5<*$I+,7)<U+M!R*,#)Q8

!!-$2!)+J"I,+<F]<D+F\#D5<*$I+,7<$*',M!-$*',A+>8

!!-$2!)+JA+<$*',]<D+F"I,+<F^''6S1+)*\,#1+)\#D5<*$I+,7)<U+M!R*,#)Q8

!!-$2!)+JA+<$*',]<D+FR#)Q6+"I,+<FS1+)*\,#1+)\#D5<*$I+,7)<U+M!R*,#)Q8

Dispatchers

!*"##!BC-$*',!$+)$,-#!-$*',!.

!!D+6>:F#D5<*$I+,!/!\#D5<*$I+,D

!!!!:)+J"I,+<F]<D+F\#D5<*$I+,7D+6>8

<$*',:F#D5<*$I+,!/!F#D5<*$I+,!EE!K+>',+!D*<,*+F

Set dispatcher

1"*!F#D5<*$I+,!/

!!\#D5<*$I+,D:)+JST+$(*',]<D+FS1+)*\,#1+)\#D5<*$I+,

F#D5<*$I+,!!!!

!!!!:J#*I_+J"I,+<F^''6P#*I]'()F+F]6'$%#)Q`(+(+74008

!!!!:D+*&',+^''6R#a+74b8

!!!!:D+*B<T^''6R#a+74Yc8

!!!!:D+*d++5-6#1+"#U+e)B#66#D7b00008

!!!!:D+*A+f+$*#')^'6#$C7,$4!&<66+,A()D^'6#$C8

!!!!:K(#6F"I,+<F^''6

EventBasedDispatcherFluent DSL

MessageQueues

• Unbounded LinkedBlockingQueue• Bounded LinkedBlockingQueue• Bounded ArrayBlockingQueue

Bounded SynchronousQueue

Plus different options per queue

1"*!<$*',D!/!-$*',A+Q#D*,C:<$*',D

1"*!<$*',D!/!-$*',A+Q#D*,C:<$*',DV',?"g^S@

1"*!<$*',D!/!-$*',A+Q#D*,C:<$*',DV',7#F8

1"*!<$*',!/!-$*',A+Q#D*,C:<$*',V',7((#F8

-$*',A+Q#D*,C:>',+<$I7>)8

-$*',A+Q#D*,C:DI(*F'J)-66

ActorRegistry

Let it crash fault-tolerance

Stolen from

Erlang

9 nines

OneForOne fault handling strategy

AllForOnefault handling strategy

Supervisor hierarchies

-66V',=)+R*,<*+QC7

!!U<T_,=>A+*,#+DX!

!!J#*I#)"#U+A<)Q+8

=)+V',=)+R*,<*+QC7

!!U<T_,=>A+*,#+DX!

!!J#*I#)"#U+A<)Q+8

Fault handlers

6#)%7<$*',8!

()6#)%7<$*',8!

D*<,*W#)%7<$*',8

D5<J)W#)%?BC-$*',@

Linking

*,<5ST#*!/!W#D*7

!$6<DD=>?R+,1#$+ST$+5*#')@X!

!$6<DD=>?^+,D#D*+)$+ST$+5*#')@8

trapExit

!*"##!R(5+,1#D',!$+)$,-#!-$*',!.

!!03.&/)!D+6>:;

!!*,<5ST#*!/!W#D*7$6<DD=>?"I,'J<K6+@8

!!><(6*[<)F6+,!/!

!!!!R'U+7=)+V',=)+R*,<*+QC7hX!h00088

!!-$2!,+$+#1+!/!.

!!!!!"#$!A+Q#D*+,7<$*',8!/2!

!!!!!!6#)%7<$*',8

Supervision

!*"##!V<(6*"'6+,<)*R+,1#$+!$+)$,-#!-$*',!.

!!&1$//0-$%-$2!5,+A+D*<,*7,+<D')M!"I,'J<K6+8!/!.

!!!!:::!EE!$6+<)!(5!'$2&/$!,+D*<,*

!!&1$//0-$%-$2!5'D*A+D*<,*7,+<D')M!"I,'J<K6+8!/!.

!!!!:::!EE!#)#*!"2)$/!,+D*<,*

Manage failure

Remote Actors

EE!(D+!I'D*!i!5',*!#)!$')>#Q

A+U'*+_'F+:D*<,*

A+U'*+_'F+:D*<,*7j6'$<6I'D*jX!kkkk8

Remote Server

Scalable implementation based on NIO (Netty) & Protobuf

•Client-initated and managed

•Server-initiated and managed

Two types of

remote actors

EE!U+*I'FD!#)!-$*',!$6<DD

D5<J)A+U'*+?BC-$*',@7I'D*X!5',*8!

D5<J)W#)%A+U'*+?BC-$*',@7I'D*X!5',*8

D*<,*W#)%A+U'*+7<$*',X!I'D*X!5',*8

Client-managedsupervision works across nodes

1"*!<$*',^,'TC!/!D5<J)W#)%A+U'*+?BC-$*',@7

!!LF<,%D*<,NX!

!!kkkk8

<$*',^,'TC!O!U+DD<Q+

Client-managedmoves actor to server

client manages through proxy

A+U'*+_'F+:,+Q#D*+,7

!!LD+,1#$+M#FNX!<$*',=>?BCR+,1#$+@8

Server-managedregister and manage actor on server

client gets “dumb” proxy handle

server part

1"*!I<)F6+!/!A+U'*+&6#+)*:<$*',V',7

!!LD+,1#$+M#FNX!

!!LF<,%D*<,NX!

!!kkkk8

I<)F6+!O!U+DD<Q+

Server-managed

client part

&6(D*+,:,+6<CB+DD<Q+7

!!$6<DD=>?"C5+=>-$*',@X!U+DD<Q+8

2&/%7+)F5'#)*!lm!&6(D*+,8!

!!D5<J)A+U'*+?"C5+=>-$*',@7!!

!!!!!!!!!!!!!!+)F5'#)*:I'D*X!

!!!!!!!!!!!!!!+)F5'#)*:5',*8

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

1"*!,+>!/!A+>7B<5?R*,#)QX!ZD+,@788

1"*!(D+,D!/!,+>:Q+*

1"*!)+JZD+,D!/!(D+,D!3!7LK#66N!m2!ZD+,7LK#66N88

,+>:DJ<57)+JZD+,D8

Managed References

1"*!(D+,D!/!",<)D<$*#')<6B<5?R*,#)QX!ZD+,@78

1"*!(D+,D!/!",<)D<$*#')<6n+$*',?ZD+,@78

Transactionaldatastructures

03.&/)!",<)D<$*#'):W'$<6:;

<*'U#$!.

!!<*'U#$!.!EE!)+D*+F!*,<)D<$*#')D!$'U5'D+

!!!!:::!EE!F'!D'U+*I#)Q!J#*I#)!<!*,<)D<$*#')

STM: API

Actors + STM = Transactors

!*"##!ZD+,A+Q#D*,C!$+)$,-#!",<)D<$*',!.

!!./01")$%1"*!D*',<Q+!/!

!!!!",<)D<$*#')<6B<5?R*,#)QX!ZD+,@78

!!-$2!,+$+#1+!/!.

!!!!!"#$!_+JZD+,7(D+,8!/2

!!!!!!D*',<Q+!3!7(D+,:)<U+!m2!(D+,8

!!!!:::!

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

1"*!<Q+)*!/!-Q+)*7h8

EE!D+)F!>()$*#')!<DC)$I,')'(D6C

<Q+)*!D+)F!7;!3!48!

1"*!,+D(6*!/!<Q+)*78!EE!F+,+>

:::!EE!(D+!,+D(6*

<Q+)*:$6'D+

Agents

Cooperates with STMTuesday, July 20, 2010

(some of the) Modules

Akka Spring

lK+<)D2

!!l<%%<M<$*#1+m'Kf+$*!#F/jUC-$*#1+=Kf+$*j!

!!!!!!!!!!!!!!!!!!!!!!*<,Q+*/j$'U:K#a:BC^=o=j!

!!!!!!!!!!!!!!!!!!!!!!*,<)D<$*#')<6/j*,(+j!

!!!!!!!!!!!!!!!!!!!!!!*#U+'(*/j4000j!E2

lEK+<)D2

Spring integration

6<%%<MD(5+,1#D#')!#F7jUCmD(5+,1#D',j8

!!6<%%<M,+D*<,*9D*,<*+QC!><#6'1+,7j-66V',=)+j!

!!!!!!!!!!!!!!!!!!!!!!!!!,+*,#+D7jpj!

!!!!!!!!!!!!!!!!!!!!!!!!!*#U+,<)Q+7j4000j8

!!!!6<%%<M*,<59+T#*D8

! !!6<%%<M*,<59+T#*8f<1<:#':e=ST$+5*#')6;<%%<M*,<59+T#*8

!!!!6;<%%<M*,<59+T#*D8

!!6;<%%<M,+D*<,*9D*,<*+QC8

!!6<%%<M<$*#1+9'Kf+$*D8

!!!!6<%%<M<$*#1+9'Kf+$*!*<,Q+*7j$'U:K#a:BC^=o=j!

!!!!!!!!!!!!!!!!!!!!!!!!6#>+$C$6+7j5+,U<)+)*j!

!!!!!!!!!!!!!!!!!!!!!!!!*#U+'(*7j4000j8

!!!!!!6<%%<M,+D*<,*9$<66K<$%D!5,+7j5,+A+D*<,*j!

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!5'D*7j5'D*A+D*<,*j;8

!!!!6;<%%<M<$*#1+9'Kf+$*8

!!6;<%%<M<$*#1+9'Kf+$*D8

6;<%%<MD(5+,1#D#')8

Spring integration

Akka Camel

!*"##!BC&')D(U+,!$+)$,-#!-$*',!40)5!&')D(U+,!.

!!-$2!+)F5'#)*Z,#!/!j>#6+MF<*<E#)5(*j

!!-$2!,+$+#1+!/!.

!!!!!"#$!UDQM!B+DD<Q+!/2!

!!!!!!6'Q:#)>'7j,+$+#1+F!qDj!>',U<*

!!!!!!UDQ:K'FC-D7$6<DD=>?R*,#)Q@88

Camel: consumer

!*"##!BC&')D(U+,!$+)$,-#!-$*',!40)5!&')D(U+,!.

!!-$2!+)F5'#)*Z,#!/!

!!!!jf+**CMI**5MEE0:0:0:0MccrrE$<U+6E*+D*j

!!-$2!,+$+#1+!/!.

!!!!!"#$!UDQM!B+DD<Q+!/2!

!!!!!!,+56C7j[+66'!qDj!>',U<*!

!!!!!!!!!!!!UDQ:K'FC-D7$6<DD=>?R*,#)Q@88

Camel: consumer

!*"##!&'U+*^,'F($+,!

!!$+)$,-#!-$*',!40)5!^,'F($+,!.

!!-$2!+)F5'#)*Z,#!/!

!!!!j$'U+*FMEE6'$<6I'D*Mc444E*+D*j

Camel: producer

1"*!5,'F($+,!/!<$*',=>?&'U+*^,'F($+,@:D*<,*

1"*!*#U+!/!j&(,,+)*!*#U+M!j!3!,$4!\<*+

5,'F($+,!O!*#U+

Camel: producer

Akka Persistence

Akka Persistence API

EE!*,<)D<$*#')<6!&<DD<)F,<mK<$%+F!B<5!

1"*!U<5!/!&<DD<)F,<R*',<Q+:)+JB<5

EE!*,<)D<$*#')<6!A+F#DmK<$%+F!n+$*',!

1"*!1+$*',!/!A+F#DR*',<Q+:)+Jn+$*',

EE!*,<)D<$*#')<6!B')Q'mK<$%+F!A+>

1"*!,+>!/!B')Q'R*',<Q+:)+JA+>

Turns the STM into ACID

Get data by id

EE!*,<)D<$*#')<6!&<DD<)F,<mK<$%+F!B<5!

1"*!U<5!/!&<DD<)F,<R*',<Q+:Q+*B<57((#F8

EE!*,<)D<$*#')<6!A+F#DmK<$%+F!n+$*',!

1"*!1+$*',!/!A+F#DR*',<Q+:Q+*n+$*',7((#F8

EE!*,<)D<$*#')<6!B')Q'mK<$%+F!A+>

1"*!,+>!/!B')Q'R*',<Q+:Q+*A+>7((#F8

For Redis only (so far)

1"*!s(+(+M!^+,D#D*+)*`(+(+?S6+U+)*"C5+@!/!!!

!!A+F#DR*',<Q+:)+J`(+(+

1"*!D+*M%^+,D#D*+)*R',*+FR+*?S6+U+)*"C5+@!/

!!A+F#DR*',<Q+:)+JR',*+FR+*

Akka Deployment

Deploy as dependency JAR in WEB-INF/lib etc.

Run as microkernel

Soon OSGi-enabled, then drop in any OSGi container (Spring DM server, Karaf etc.)

Deployment

Security

...and much more

GuiceJTA

Learn morehttp://akkasource.org

EOFTuesday, July 20, 2010

?Tuesday, July 20, 2010

Simpler Concurrency, Scalability & Fault-tolerance through …assets.en.oreilly.com/1/event/45/Akka_...

Documents

Transcript of Simpler Concurrency, Scalability & Fault-tolerance through …assets.en.oreilly.com/1/event/45/Akka_...

Advanced Rendering for IBM FileNetpublic.dhe.ibm.com/software/data/sw-library/ecm... · • Architecture • Massive Scalability • High Availability/ Fault Tolerance • Management

Achieving Performance, Scalability, and Availability ...€¦ · Achieving Performance, Scalability, and Availability Objectives ... Average latency ... Achieving Performance, Scalability,

Storm - assets.en.oreilly.comassets.en.oreilly.com/1/event/75/Storm_ distributed and fault-tolerant... · Storm Guaranteed data processing Horizontal scalability Fault-tolerance No

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

Fault tolerance performance and scalability comparison: NEC hardware-based FT vs. software-based FT

Akka: Simpler Scalability, Fault-Tolerance, Concurrency & Remoting through Actors

BIZTALK SERVER 2006 HIGH AVAILABILITY, FAULT TOLERANCE, AND SCALABILITY Andrew Babiec Manager, Development Services Tallan.

Integrated Coverage and Connectivity Configuration in ...xwang/papers/sensys03_ccp.pdf · provide sufficient coverage for distributed detection. Provided scalability and fault-tolerance,

EMERGENCY E-MEDICAL INDUSTRY DATACENTRE TRANSPORT … · Thanks to its fault tolerant architecture, concurrent maintainability and hot scalability, NextEnergy guarantees ... The input

Scalability and Algorithm-Based Fault Tolerance for Plasma Physics Simulations …helper.ipam.ucla.edu/publications/dmc2017/dmc2017_14139.pdf · 2017-02-03 · Big Data Meets Computation

Fault tolerance performance and scalability comparison ... · The hardware-based fault tolerance in the NEC Express5800/R320d-M4 works differently. Its two servers operate in lockstep

Brava scalability and fault tolerance - from ICG and Atidan

SCALABLE VIDEO MANAGEMENT AND … fault-tolerant software, dist ributed architecture, and multiple levels of redundancy † Provides scalability and modular expansion † Provides

Achieving Massive Scalability And Total Fault Isolation ... · Oracle Sharding Architecture Overview • A data tier architecture introduced in 12.2 , data horizontally partitioned

Blood Simpler

Scalable Solutionsgotocon.com/dl/jaoo-aarhus-2010/slides/JonasBonen_AkkaSimpler... · Akka: Simpler Concurrency, Scalability & Fault-tolerance through Actors Jonas Bonér Scalable

Concurrency, Scalability & Fault-tolerance 2.0 with Akka Actors & STM

1 Persistence. 2 Persistence Usage Scalability –disk cheaper than memory Fault recovery –last known state maintained through recovery Parallel processing.

Introduction on Sensor Networkshy439/lectures/lecture6.sensor_networks.pdf · Factors Infuencing WSN Design • Fault tolerance • Scalability • Production costs • Hardware constraints

Akka - LTHfileadmin.cs.lth.se/cs/Education/EDA015F/2013/Akka1-presentation.pdf · Akka: A Solution for Concurrency, Fault-tolerance and Scalability 5 Open source toolkit and runtime