Akka is a toolkit for building concurrent, distributed, and fault-tolerant applications. It provides tools like actors for concurrency, remoting for distribution across servers, and supervision for fault tolerance through restarting of actors after exceptions. The document then provides examples of using actors for concurrency through message passing, distributing actors across multiple servers using remoting, and supervising actors to restart them after exceptions through a supervisor actor. It also gives code samples and suggestions for further reading on Akka.

1. Basics of
Akka

2. Akka
is a toolkit
to build
*concurrent,
*distributed,
*fault torerant
apps.

3. Akka
is a toolkit
to build
*concurrent,
並行計算したり
*distributed,
分散処理したり
*fault torerant
耐障害性があるような
apps.

4. concurrent
-> Actors
distributed
-> Remoting
fault torerant
-> Supervision

5. concurrent
アクター
-> Actors
distributed
リモートアクター
-> Remoting
fault torerant
監視
-> Supervision

6. Actors

8. Merchant
Warrior

14. Actors States
Messages

15. Each actor runs
concurrently

16. Actors communiate
through messages

17. Each actor has state

18. Actors are scalable

19. Too much load!

20. I scaaale out!

21. Remoting

22. Server1
It’s O.K.

23. Server1
Out of cap

24. Server1 Server2
Remoting
Ditribute across servers

25. Supervision

27. Supervisor
Children

28. exception exception

29. restart! restart!

30. Some code

31. import akka.actor._
import akka.util.Timeout
import akka.pattern.ask
import concurrent.duration._
import concurrent.Future
import
concurrent.ExecutionContext.Implicits.global

32. case class Pay(amount: Int)
case class Apple()
class Merchant extends Actor {
var gold: Int = 0
def receive = {
case Pay(amount) if amount >= 50 =>
gold += 50
sender ! Apple()
}
}

33. val system = ActorSystem()
val merchant: ActorRef =
system.actorOf(Props(new Merchant))

34. val future: Future[Apple] = (merchant ?
Pay(50)).mapTo[Apple]

35. // Callbacks
future.onSuccess {
case apple: Apple =>
// Eat it
}
future.onFailure {
case failure =>
println("onFailure called with: " +
failure)
}

36. // Wait for the reply
import concurrent.Await
val result: Apple =
Await.result(future, atMost = 10
seconds)

37. // for-comprehensions
for {
apple <- future
foo <- anotherFuture
} yield doSomething(apple, foo)

38. See:
SIP-14 - Futures and Promises
http://docs.scala-lang.org/
sips/pending/futures-
promises.html

39. Scaling
out?

40. val merchant: ActorRef =
system.actorOf(Props(new Merchant))

41. val router: ActorRef =
system.actorOf(
Props[Merchant]
.withRouter(
SmallestMailboxRouter(
nrOfInstances = 10
)
),
name = "merchantRouter"
)

42. val future: Future[Apple] = (merchant ?
Pay(50)).mapTo[Apple]

43. val future: Future[Apple] = (router ?
Pay(50)).mapTo[Apple]

44. Excercise

45. “Hi!”

46. “Hi!”
“Hi!”

47. “Hi!”
“Hi!”
class EchoActor extends Actor {
def receive = {
case <1> =>
sender ! <2>
}
}

48. “Hi!”
“Hi!”
class EchoActor extends Actor {
def receive = {
case msg =>
sender ! msg
}
}

49. Further
topics

50. Akka is composed
of many tools:
actor, testkit, remote,
cluster, transactor,
agent, zeromq, camel, ...
Just use what you need

51. See:
http://akka.io/docs/

52. Read it now!
http://www.manning.com/roestenburg/

53. Thank you!