Akka (Actor) in Practice

Akka (Actor) in Practice Sunghyun Hwang !1

Software Engineer @Rainist We are making Banksalad !2

Akka !5

Akka is the implementation of the Actor Model on the
JVM [1] !6

Actor Model !7

!8 class Pizza { private var slices = 8 def
eat(nrOfSlices: Int = 1): Int = { if (slices >= nrOfSlices) { slices = slices - nrOfSlices return nrOfSlices } else { throw OutOfPizzaException } } }

!9 class Pizza { private var slices = 8 def
eat(nrOfSlices: Int = 1): Int = { if (slices >= nrOfSlices) { slices = slices - nrOfSlices return nrOfSlices } else { throw OutOfPizzaException } } }

!10 Pizza Person("A") Person("B")

!11 Pizza Person("A") Person("B") .eat(6)

!12 Pizza Person("A") Person("B") .eat(6)

!13 Pizza Person("A") Person("B") .eat(6) .eat(3)

!14 Pizza Person("A") Person("B") .eat(6) .eat(3) OOP

!15 Pizza Person("A") Person("B") .eat(6) .eat(3) OOP Pizza Person("A") Person("B")
T1 T2

.eat(6) .eat(3) T1 T2

!18 # ❓

!19 .eat(6) .eat(3) Unfortunately, the encapsulation model of objects does
not guarantee anything about what happens in that section.

!20 Unfortunately, the encapsulation model of objects does not guarantee
anything about what happens in that section. (…) Now, imagine this issue compounded by the existence of many threads. [2] .eat(6) .eat(3) .eat(2) .eat(8)

An actor is a container for State, Behavior, a Mailbox,
Child Actors and a Supervisor Strategy. All of this is encapsulated behind an Actor Reference. [3] !21

!22 PizzaActor

!23 PizzaActor

!24 PizzaActor

!25 PizzaActor % &

!26 PizzaActor '( % &

!28 PizzaActor '( % & ✉

!34 PizzaActor '( % & 0

!35 PizzaActor '( % & 0 ⚡

OOP to me means only messaging, local retention and protection
and hiding of state-process, and extreme late-binding of all things. — Alan Kay [4] !37

The actor model adopts the philosophy that everything is an
actor. [5] !38

What Akka is For !39

The Actor model alone, while great for many use cases,
do not solve all concurrency and scalability problems. !40

The Actor model alone, while great for many use cases,
do not solve all concurrency and scalability problems. (…) In addition to STM, Akka provides several other concurrency abstractions such as Agents and Dataﬂow Concurrency. [6] !41

Akka is a toolkit for building highly concurrent, distributed, and
resilient message-driven applications for Java and Scala [1] !42

• Actor (Mostly) • I/O • Cluster • Cluster Tools
• Persistence • Streams • Alpakka • HTTP • Typed !43 Akka

3 Months with Akka !44

!45 Recommending Actor

!46 Recommending Actor Maximizing Actor Maximizing Actor

!47 Recommending Actor Maximizing Actor Maximizing Actor Computing Actor Computing
Actor Computing Actor Computing Actor Computing Actor Computing Actor

!48 Recommending Actor Maximizing Actor Maximizing Actor Computing Actor Computing
Actor Computing Actor Computing Actor Computing Actor Computing Actor

!49 Recommending Actor Maximizing Actor Maximizing Actor

Akka is a tool, not a framework. !50

Akka is a tool, not a framework. !51 trade-off

!52 override def receive: Receive = { case WannaEatPizza(nr) ⇒
eat(nr) case DoNotWannaEatPiazza ⇒ ??? }

!53 override def receive: Receive = { case WannaEatPizza(nr) ⇒
eat(nr) case DoNotWannaEatPiazza ⇒ ??? } type Receive = PartialFunction[Any, Unit]

override def receive: Receive = { case WannaEatPizza(nr) ⇒ eat(nr)
case OrderPizza(addr) ⇒ procOrder(addr) case CancelOrder(num) ⇒ cancel(num) case ShowPizzaMenu ⇒ sender ! pizzas case DoNotWannaEatPiazza ⇒ sender ! SoWhat }

Single Responsibility Principle !55

“A class should have only one reason to change.” —
Robert C. Martin [7] !56

!57 class CounterActor extends Actor { var cnt: Int =
0 override def receive = { case Tick ⇒ cnt = cnt + 1 sender ! cnt } }

!58 def ticker(cnt: Int): Receive = { case Tick ⇒
context become ticker(cnt + 1) }

One actor is no Actor !59

Actor → Concurrency !60

Concurrency → Actor !61

!62 class SomeActor extends Actor { override def receive =
{ case id: Int ⇒ val card = database.query(s"SELECT * FROM card WHERE id = $id") val cached = cache.get(card.slug) sender ! cached } }

!63 Future { val card = database.query(s"SELECT * FROM card
WHERE id = $id") cache.get(card.slug) }

!64 val a1 = actor ? 1 val a2 =
actor ? 2 for { r1 ← a1 r2 ← a2 } yield (r1, r2) val f1 = fut(1) val f2 = fut(2) for { r1 ← f1 r2 ← f2 } yield (r1, r2)

Future is Composable, Actor is not. !65

class StreamActor extends Actor { override def receive = {
case Data(x, y, z) ⇒ other ! convert(x, y, z) } } !66

• Monix.Observable • FS2 • RxJava/RxScala !67

!68 1 2 3

!69 1 2 3 unidirectional

!70 1 2 3 unidirectional 1 2 3 10 20
30

!71 1 2 3 unidirectional 1 2 3 10 20
30 bidirectional

!72 “To a man with a hammer, everything looks like
a nail.” — Mark Twain

We are hiring! https://rainist.com/recruit/engineer • Back-end Engineer • Data Engineer
• Data Scientist • Android Engineer • iOS Engineer • QA Engineer • Security Engineer • … X Engineer !73

Q&A !74

Materials !75 • [Akka Oﬃcial Documents](https://akka.io) • [The Zen of
Akka - by Konrad Malawski](https://www.youtube.com/ watch?v=vgFoKOxrTzg) • [The best is yet to come - State of Akka in 2017 by Konrad Malawski] (https://www.youtube.com/watch?v=CGyIPVGB2-4) • [Akka: Simpler Scalability, Fault-Tolerance, Concurrency & Remoting through Actors](https://www.slideshare.net/jboner/akka-simpler- scalability-faulttolerance-concurrency-remoting-through-actors/)

!76 • [1] https://akka.io • [2] https://doc.akka.io/docs/akka/current/guide/actors-motivation.html#the- challenge-of-encapsulation • [3]
https://doc.akka.io/docs/akka/2.5/general/actors.html#what-is-an-actor- • [4] http://www.purl.org/stefan_ram/pub/doc_kay_oop_en • [5] https://en.wikipedia.org/wiki/Actor_model#Fundamental_concepts • [6] https://www.lightbend.com/blog/why-akka • [7] <Agile Software Development, Principles, Patterns, and Practices> (2003, Martin, Robert C.) References

Akka (Actor) in Practice

Akka (Actor) in Practice

More Decks by Sunghyun Hwang

Other Decks in Programming

Featured

Transcript