Concurrent and Distributed Applications with Akka, Java and Scala

Concurrent and Distributed Applications with Akka, Java and Scala Buenos Aires, Argentina, Oct 2012 @frodriguez

Moore’s law Moores law says that every 18 months,the number of transistors that can ﬁt within a given area on a chip doubles.

Moore’s law Moores law says that every 18 months,the number of transistors that can ﬁt within a given area on a chip doubles. Pages law says that every 18 months software becomes twice as slow

Modern CPUs intel ® Xeon®processor

Modern CPUs Small improvements in intel ® execution speed Xeon®processor

Modern CPUs Small improvements in intel ® execution speed but... Xeon®processor

Modern CPUs Small improvementsCore Core Core Core inCore Core Core Core execution speed but...Core Core Core Core ImprovedCore Core Core Core parallelism supportMulticore processors

Alternative Moore’s & Page’s laws Every 18 months, the number of cores per chip doubles.

Alternative Moore’s & Page’s laws Every 18 months, the number of cores per chip doubles. Every 18 months the number of IDLE cores doubles

Modern Applications Demands...

Modern Applications Demands...Scalability

Modern Applications Demands...Scalability Vertical (scaling up) - Concurrency Horizontal (scaling out) - Distribution

Modern Applications Demands...Scalability Vertical (scaling up) - Concurrency Horizontal (scaling out) - Distribution Size (Resources, Users, ...) Geographically Admin / Management

Modern Applications Demands...

Modern Applications Demands...High Availability Fault Tolerance (local & distributed)

Modern Applications Demands...High Availability Fault Tolerance (local & distributed)Performance & Low Latency Efﬁcient Use of Resources (CPU & Memory) Asynchronous (reduced latency) Distributed (cheap machines, better performance / $)

How to WriteConcurrent Applications forMulticore Processors ?

Traditional ApproachThreads (pools processing tasks) Shared (and mutable) State Synchronization and Locking Concurrent Collections

Traditional Threads ?

Traditional Threads ?process(...){}

Traditional Threads ?process(...){ Computing Reading State from Heap I/O (e.g: Disk, Network, DBs) Processing Results Updating State in the Heap Returning Results}

Traditional Threads ?process(...){ Computing Thread Suspended Reading State from Heap d ke c I/O (e.g: Disk, Network, DBs) Blo Processing Results Updating State in the Heap Returning Results}

Traditional Threads ?process(...){ Add concurrency... Computing Reading State from Heap I/O (e.g: Disk, Network, DBs) Processing Results Updating State in the Heap Returning Results}

Traditional Threads ? process(...){ Computing RequiresSynchronization Reading State from Heapcan be blocked I/O (e.g: Disk, Network, DBs) Processing Results RequiresSynchronization Updating State in the Heapcan be blocked Returning Results }

Traditional Threads ? process(...){ Computing RequiresSynchronization Reading State from Heapcan be blocked I/O (e.g: Disk, Network, DBs) Bad for CPU caches Processing Results RequiresSynchronization Updating State in the Heapcan be blocked Returning Results }

Traditional Threads ? How many threads ? Computing Reading State from Heap I/O (e.g: Disk, Network, DBs) Processing Results Updating State in the Heap Returning Results

Traditional Threads ? How many threads ? Computing Reading State from HeapI/O (e.g: Disk, Network, DBs) Processing Results Updating State in the Heap Returning Results

Traditional Threads ? How many threads ? Computing Reading State from HeapI/O (e.g: Disk, Network, DBs) Improves with threads (Assuming blocking, Processing Results non-async I/O is used...) Updating State in the Heap Returning Results

Traditional Threads ? How many threads ? Computing Degrades with more threads than cores Reading State from Heap Context Switching,I/O (e.g: Disk, Network, DBs) Contention, L1 & L2 Caches Processing Results Updating State in the Heap Returning Results

What About Latency ?Latency (time to ﬁrst item) Fetching and Mapping N Items Client DB BizThread by task (instead of by layer). Sync Results

What About Latency ? Latency (time to ﬁrst item) Fetching and Mapping N Items Client DB Biz Parallelism by Layer - Asynchronous and Partial ResultsFrom Request/Response to Request Stream/Response Stream

How to WriteDistributed Applications ?

Traditional Approach RPC (WS, RMI, ...)Queues (JMS, AMQP, STOMP, etc), Raw Sockets

Traditional Approach RPC (WS, RMI, ...)Queues (JMS, AMQP, STOMP, etc), Raw Sockets Local != RemoteLocal should be an optimization, not a forced early decision...

Akka “Akka is a toolkit and runtime for building highly concurrent,distributed, and fault tolerant event- driven applications on the JVM. ” Based on the actor model

What is an Actor ? Actors are objects whichencapsulate state and behavior Communicate exclusively by exchanging messages Conceptually have their own light-weight threadNo Need for Synchronization

Actors Actor State Behavior

Actors ActorMailbox State Behavior

Actors C B A ActorMailbox State Behavior

Actors C B ActorMailbox State Behavior A

Actors C B ActorMailbox State Behavior

Actors Millions of C B Actor Actors MailboxOne per Actor State Behavior

Actors Number of ThreadsProportional to number of Cores Millions of C B Actor Actors MailboxOne per Actor State Behavior

Actors: Processing Messages /myactorA State Behavior

Actors: Processing Messages /myactor State Behavior A

Actors: Processing Messages /myactor New State State Behavior Change State

Actors: Processing Messages /myactor State Behavior New Behavior Change State Change Behavior

Actors: Processing Messages /myactor /someactor State State Behavior B Behavior Change State Change Behavior Send a Message

Actors: Processing Messages /myactor /someactor B State State Behavior Behavior Change State Change Behavior Send a Message

Actors: Processing Messages /myactor /someactor State State Behavior Behavior B Change State Change Behavior Send a Message

Actors: Processing Messages /myactor /someactor State State Behavior Behavior /myactor/child Change State State Change Behavior Send a Message Behavior Create Actors

Hello World ActorDeﬁne class HelloWorld extends Actor { def receive = { case msg => printf(“Received %sn”, msg) } }Create val system = ActorSystem(“MySystem”) val hello = system.actorOf(Props[HelloWorld], “hello”)Send Message hello ! “World”

Counter ActorDeﬁne class Counter extends Actor { var total = 0 def receive = { case Count(value) => total += value case GetStats => sender ! Stats(total) } }Protocol case class Count(n: Int) case class Stats(total: Int) case object GetStats

Sending a Message/actorA /actorB State StateBehavior Behavior

Sending a Message /actorA /actorB State State Behavior BehavioractorB ! A

Sending a Message /actorA /actorB State State Behavior A BehavioractorB ! A

Sending a Message /actorA /actorB A State State Behavior BehavioractorB ! A

Sending a Message /actorA /actorB State State Behavior Behavior AactorB ! A

Sending a Message /actorA /actorB State State Behavior Behavior AactorB ! A sender ! B

Sending a Message /actorA /actorB State State Behavior Behavior BactorB ! A sender ! B

Sending a Message /actorA /actorBB State State Behavior Behavior actorB ! A sender ! B

Sending a Message /actorA /actorB State State Behavior B BehavioractorB ! A sender ! B

Sending a Message /actorA /actorB State State Behavior BehavioractorB ! A sender ! B

Sending a Message /actorA /actorB State State Behavior BehavioractorB ! A sender ! BactorB tell A sender tell B

Sending a Message/actorA /actorB State StateBehavior Behavior /actorC State Behavior

Sending a Message /actorA /actorB State State Behavior BehavioractorB tell (A, actorC) /actorC State Behavior

Sending a Message /actorA /actorB State State Behavior A BehavioractorB tell (A, actorC) /actorC State Behavior

Sending a Message /actorA /actorB A State State Behavior BehavioractorB tell (A, actorC) /actorC State Behavior

Sending a Message /actorA /actorB State State Behavior Behavior AactorB tell (A, actorC) /actorC State Behavior

Sending a Message /actorA /actorB State State Behavior Behavior AactorB tell (A, actorC) sender ! B /actorC State Behavior

Sending a Message /actorA /actorB State State Behavior Behavior BactorB tell (A, actorC) sender ! B /actorC State Behavior

Sending a Message /actorA /actorB State State Behavior BehavioractorB tell (A, actorC) sender ! B /actorC B State Behavior

Sending a Message /actorA /actorB State State Behavior BehavioractorB tell (A, actorC) sender ! B /actorC State Behavior B

Sending a Message /actorA /actorB State State Behavior BehavioractorB tell (A, actorC) sender ! B /actorC State Behavior

Forward a Message/actorA /actorB State StateBehavior Behavior /actorC State Behavior

Forward a Message /actorA /actorB State State Behavior BehavioractorB ! A /actorC State Behavior

Forward a Message /actorA /actorB State State Behavior A BehavioractorB ! A /actorC State Behavior

Forward a Message /actorA /actorB A State State Behavior BehavioractorB ! A /actorC State Behavior

Forward a Message /actorA /actorB State State Behavior Behavior AactorB ! A /actorC State Behavior

Forward a Message /actorA /actorB State State Behavior Behavior AactorB ! A actorC forward B /actorC State Behavior

Forward a Message /actorA /actorB State State Behavior Behavior BactorB ! A actorC forward B /actorC State Behavior

Forward a Message /actorA /actorB State State Behavior BehavioractorB ! A actorC forward B /actorC B State Behavior

Forward a Message /actorA /actorB State State Behavior BehavioractorB ! A actorC forward B /actorC State Behavior B

Forward a Message /actorA /actorB State State Behavior BehavioractorB ! A actorC forward B /actorC State sender ! C Behavior B

Forward a Message /actorA /actorB State State Behavior BehavioractorB ! A actorC forward B /actorC State sender ! C Behavior C

Forward a Message /actorA /actorBC State State Behavior Behavior actorB ! A actorC forward B /actorC State sender ! C Behavior

Forward a Message /actorA /actorB State State Behavior C BehavioractorB ! A actorC forward B /actorC State sender ! C Behavior

Forward a Message /actorA /actorB State State Behavior BehavioractorB ! A actorC forward B /actorC State sender ! C Behavior

Ask & Pipe PatternsAsk val response = actor ? Message response onSuccess { case Response(a) => printf(“Response %s”, a) }Pipe val response = actor ? Message response pipeTo actor2

Mailbox UnboundedMailbox (default) UnboundedPriorityMailbox BoundedMailbox (*) BoundedPriorityMailbox (*)* May produce deadlocks if used unproperly

RoutingRound Robin Router val actor = system.actorOf( Props[MyActor].withRouter(RoundRobinRouter(4)), name = “myrouter” )Using actor with routers (no changes) actor ! Message

RoutingRoundRobinRouterRandomRouterSmallestMailboxRouterBroadcastRouterScatterGatherFirstCompletedRouter

Routing ConfigurationConfiguration overrides code akka.actor.deployment { /myrouter { router = round-robin nr-of-instances = 8 } }Routers from Config val actor = system.actorOf( Props[MyActor].withRouter(FromConfig()), name = “myrouter” )

RemotingAccessing remote actorval actor = system.actorFor( “akka://sys@server:2552/user/actor”)Using remote actor (no changes) actor ! Message // Replies also work ok sender ! Response

Remote DeploymentCode without changes val actor = system.actorOf( Props[MyActor], name = “myactor” )Conﬁguration akka.actor.deployment { /myactor { remote = “akka://sys@server:2553” } }

Remote Deployment (routers) akka.actor.deployment { /myrouter { router = round-robin nr-of-instances = 8 target { nodes = [“akka://sys@server1:2552” “akka://sys@server2:2552”] } } } Routers from Conﬁg val actor = system.actorOf( Props[MyActor].withRouter(FromConfig()), name = “myrouter” )

Fault Tolerance Supervision Hierarchies across machinesoverride val supervisorStrategy = OneForOneStrategy(...){ case _: ArithmeticException => Resume case _: NullPointerException => Restart case _: IllegalArgumentException => Stop case _: Exception => Escalate}

Thanks @frodriguezfrodriguez <at> gmail.com

http://www.scoop.it	840
http://www.redditmedia.com	49
https://twitter.com	27
https://si0.twimg.com	12
http://www.linkedin.com	4
http://twitter.com	3
http://pinterest.com	2
https://mail.google.com	1
http://webcache.googleusercontent.com	1
https://abs.twimg.com	1

Concurrent and Distributed Applications with Akka, Java and Scala

by Fernando Rodriguez on Oct 11, 2012

Accessibility

Categories

Upload Details

Usage Rights

10 Embeds 940

Statistics

Concurrent and Distributed Applications with Akka, Java and Scala Presentation Transcript