This document provides an introduction and overview of Akka, an open-source toolkit for building concurrent, distributed, and fault-tolerant applications on the JVM. It discusses the benefits of the actor model for concurrency, key Akka concepts including actors, messages, dispatchers, and supervision. It provides examples of actor definitions and message passing. The document aims to explain when and why Akka would be useful for building reactive and scalable applications.

1. INTRODUCTION TO AKKA
Roy Russo
1

2. Who am I?
• Former JBoss Portal Co-Founder
• LoopFuse Co-Founder
• ElasticHQ Founder
• http://www.elastichq.org
• Co-Author, Elasticsearch In Action
• Chief Architect, Altisource Labs
• VP Engineering, Predikto
2

3. Agenda
• The case for an Actor Model
• Akka
• Actor Systems
• Deployment Diagrams
3

4. Moore’s Law
The number of transistors on a chip will double
approximately every 18 months.
~ Gordon Moore, 1965
4

5. Moore’s Law
5

6. Moore’s Law
• Early 2000:
• Chips got BIG
• Signals couldn’t reach whole chip in one clock
cycle.
• Heat dissipation issues.
6

7. Moore’s Law
7
• Multi-core processors
• Multiple calculations in parallel
• CPU speeds are likely to not increase any time soon.

8. The Free Lunch is Over
8
• Build your applications to…
• take advantage of advances in new processors.
• take advantage of distributed computing.
• operate in a concurrent fashion!

9. Parallelize!
• Parallelism: When two threads are executing
simultaneously.
9

10. Threads
10
• Shared (mutable) state
• Deadlocks
• LiveLocks
• Thread Starvation
• Race Condition

11. “95% of synchronized
code is broken. The
other 5% is written by
Brian Goetz.”
11

12. Is Joe Armstrong Right?
• The world is concurrent. Things happen in parallel.
• Groups of people have no shared state.
• You have your memory. I have mine.
• Communication by messages; sound, light.
• State updates based on messages.
• Sh*t happens. (Things Fail)
• From: https://pragprog.com/articles/erlang
12

13. Alternatives?
13
Software Transactional Memory (STM)
Message-Passing Concurrency (Actors)
Dataflow Concurrency

14. 14
ACTORS

15. Actors
• From a 1973 paper, written by Carl Hewitt
• Erlang, Occam, Oz
• Encapsulate state and behavior
• Implement Message-Passing Concurrency
15

16. • Share Nothing.
• No need to synchronize.
• Isolated. Lightweight event-based Processes.
• ~ 6.5m on 4GB RAM
• Communicate through Messages.
• Asychronous and Non-Blocking
• Messages are immutable
• Each actor has a mailbox (message queue)
• Supervision-based failure management.
16
Actor Model of Concurrency

17. 17

18. 18

19. Akka
Akka is a toolkit for building
Concurrent
Distributed
Fault-Tolerant
applications.
19
Actors
Remoting
Supervision

20. When to Akka?
• When you need to build a system that:
• reacts to Events … Event-Driven
• reacts to Load … Scalable
• reacts to Failure … Resilient
• reacts to Users … Responsive
20
REACTIVE APPLICATIONS

21. Actor System
Chat Architecture
21
Cassandra
Cluster
Elasticsearch
Cluster
User 1
websocket
Controllers
Services
Users
websocket
async
async async
async

22. Akka Actor
22
mailbox • Lightweight object
Actor
Behavior
State
• ~300 bytes/instance
• Keeps internal state
• Asynch / non-blocking
• Messages kept in mailbox
• Persistence
• Small call stack =
• Scalable and fast

23. 23
When an actor receives a message…
• Actors can:
• Create new Actors
• Sends messages to
Actors
• Designate how it should
handle the next message
Actor
Behavior
State
mailbox

24. 24
Scale UP & OUT
AKKA
Concurrent (more cores)
Distributed (more nodes)

25. Some code, for the bored…
25

26. Sample pom
26
<dependency>
<groupId>com.typesafe.akka</groupId>
<artifactId>akka-actor_2.10</artifactId>
<version>${akka.version}</version>
</dependency>
<dependency>
<groupId>com.typesafe.akka</groupId>
<artifactId>akka-persistence-experimental_2.10</artifactId>
<version>${akka.version}</version>
</dependency>
<dependency>
<groupId>com.typesafe.akka</groupId>
<artifactId>akka-cluster_2.10</artifactId>
<version>${akka.version}</version>
</dependency>
<dependency>
<groupId>com.typesafe.akka</groupId>
<artifactId>akka-slf4j_2.10</artifactId>
<version>${akka.version}</version>
</dependency>
<dependency>
<groupId>org.scala-lang</groupId>
<artifactId>scala-library</artifactId>
<version>${scala.version}</version>
</dependency>

27. Actor System
27
• Actors created within this context/container.
• Manage shared facilities:
• scheduling, logging, configuration, etc…
• Can have many per JVM with different configs
• Can contain millions of actors.

28. Actor System
28
public void init() throws Exception {
actorSystem = ActorSystem.create("chatActorSystem");
}

29. Actor System
29
<bean id="actorSystemService" class="com.streamproject.akka.ActorSystemService"
init-method="init" destroy-method="destroy">
</bean>
On app-boot with Spring… (applicationContext.xml)

30. Actor System
30
/**
* Note that this will throw on servlet container shutdown. They are false alarms in Tomcat regarding
* Threads not being terminated correctly. The Thread.sleep call is merely here to make the noise less
* noisy.
*/
public void destroy() throws Exception {
actorSystem.shutdown();
Thread.sleep(5000);
}

31. Actor System - Configuration
31
akka {
application.conf || application.json || application.properties
# Loggers to register at boot time (akka.event.Logging$DefaultLogger logs
# to STDOUT)
loggers = ["akka.event.slf4j.Slf4jLogger"]
# Log level used by the configured loggers (see "loggers") as soon
# as they have been started; before that, see "stdout-loglevel"
# Options: OFF, ERROR, WARNING, INFO, DEBUG
loglevel = "DEBUG"
# Log level for the very basic logger activated during ActorSystem startup.
# This logger prints the log messages to stdout (System.out).
# Options: OFF, ERROR, WARNING, INFO, DEBUG
stdout-loglevel = "DEBUG"
actor {
provider = "akka.cluster.ClusterActorRefProvider"
…
}

32. Actor System - Configuration
32
• Custom config naming/loading
• Configuration by string
• Override configuration values
myconfig.conf
public void init() throws Exception {
Config conf = ConfigFactory.load(“myconfig”);
actorSystem = ActorSystem.create(“chatActorSystem”, conf);
}

33. Actor System
33
Actor System
Actor System location transparency
Event
• Remote and local process
actors treated the same
• Unified prog. model for
multicore and distributed
computing
msg

34. ActorRef
34
ActorRef Mailbox
Actor
Instance
Points to Actor.
Delivers to Mailbox

35. Mailbox
35
ActorRef Mailbox
Actor
Instance
Invokes Actor Instance with Message.
Runs on a dispatcher - abstracts threading

36. Actor Instance
36
ActorRef Mailbox
Your Code Here
Actor
Instance

37. The 4 Actor Operations
37

38. The 4 Actor Operations
• DEFINE
1. CREATE
2. SEND
3. BECOME
4. SUPERVISE
38

39. DEFINE
39
public class MyActor extends UntypedActor {
public void onReceive(Object message) throws Exception {
}
}

40. CREATE
40
Creates a top-level Actor
ActorSystem mySystem = ActorSystem.create("MyActorSystem");
ActorRef myActor = mySystem.actorOf(new Props(MyActor.class),"myActor");

41. DEFINE - non-default constructor
41
public class PersistEventProcessor extends UntypedActor {
private SearchService searchService;
public PersistEventProcessor(SearchService searchService) {
this.messageEventService = messageEventService;
this.searchService = searchService;
}
@Override
public void onReceive(Object obj) throws Exception {…}
}

42. 42
CREATE - non-default constructor
final ActorRef actorRef = actorSystemService.getActorSystem()
.actorOf(Props.create(PersistEventProcessor.class, searchService));
actorRef.tell(new PersistMessageEventCommand(event), null);

43. CREATE - Child Actor
43
public class SupervisorActor extends UntypedActor
{
ActorRef myChildActor = getContext().actorOf(new
Props(MyChildActor.class), “myChildActor” +
UUID.randomUUID());
}

44. SEND
44
• Fire and Forget
• Asynch
• No expected reply
• tell()
• Send and Receive
• Asynch
• Expects reply (Future)
• ask()

45. SEND - tell()
45
actor.tell(message);
// Explicit passing of sender actor reference
actor.tell(msg, getSelf());

46. SEND - ask()
46
import static akka.patterns.Patterns.ask;
Future<Object> future = ask(actor, message, timeout);
future.onSuccess(new OnSuccess<Object>() {
public void onSuccess(String result) {
System.out.println(result);
}
});
more on Futures in a bit…

47. SEND - An ask() reply
47
try {
String result = operation();
getSender().tell(result, getSelf());
} catch (Exception e) {
getSender().tell(new akka.actor.Status.Failure(e), getSelf());
throw e;
}

48. BECOME
48
• Dynamically redefines actor behavior
• Reactively triggered by message
• Like changing an interface, or implementation on-the-fly

49. BECOME
49
public class PingPongActor extends UntypedActor {
static String PING = "PING";
static String PONG = "PONG";
int count = 0;
public void onReceive(Object message) throws Exception {
if (message instanceof String) {
if (((String) message).matches(PING)) {
System.out.println("PING");
count += 1;
Thread.sleep(100);
getSelf().tell(PONG);
getContext().become(new Procedure<Object>() {
public void apply(Object message) {
if (message instanceof String) {
// do Something
}
}
}
});
if (count > 10)
getContext().stop(getSelf());
…

50. SUPERVISE
• Manage another actor’s failure
• Supervisors receive notifications, and can react upon
failure
• Every actor has a default supervisor strategy
• Can be overriden
• OneForOneStrategy (def)
• AllForOneStrategy
50

51. SUPERVISE
51
• On Failure, a supervisor defines what happens next:
• resume child, and keep internal state
• restart child, and wipe internal state
• stop child permanently
• stop itself and escalate the error
• AllForOneStrategy, affects all children.

52. SUPERVISE
52
public class Supervisor extends UntypedActor {
private static SupervisorStrategy strategy =
new OneForOneStrategy(10, Duration.create("1 minute"),
new Function<Throwable, Directive>() {
@Override
public Directive apply(Throwable t) {
if (t instanceof ArithmeticException) {
return resume();
} else if (t instanceof NullPointerException) {
return restart();
} else if (t instanceof IllegalArgumentException) {
return stop();
} else {
return escalate();
}
}
});
@Override
public SupervisorStrategy supervisorStrategy() {
return strategy;
}

53. SUPERVISE
53
http://doc.akka.io/docs/akka/snapshot/java/fault-tolerance-sample.html

54. SUPERVISE
• A contrast to Failure Management in Java
• You get one thread to control.
• If the thread blows up, then what?
• Defensive programming:
• Mix error handling within the thread
• == tangled business logic + error handling
• Errors don’t propagate between threads
54

55. Stopping Actors
55
//first option of shutting down the actors by shutting down the ActorSystem
system.shutdown();
//second option of shutting down the actor by sending a poisonPill message
actor.tell(PoisonPill.getInstance());
//third option of shutting down the actor
getContext().stop(getSelf());
//or
getContext().stop(childActorRef);

56. Killing Actors
56
actor.tell(Kill.getInstance());
• Synchronous
• Sends ActorKilledException to parent

57. UntypedActor API
• getSelf() : me
• getSender() : reply-to
• getContext() :
• factory for child actors
• get parent
• system the actor belongs to
• supervisionStrategy()
• onReceive(msg)
57

58. UntypedActor API
58
public void preStart() {
}
public void preRestart(Throwable reason, scala.Option<Object> message) {
for (ActorRef each : getContext().getChildren()) {
getContext().unwatch(each);
getContext().stop(each);
}
postStop();
}
public void postRestart(Throwable reason) {
preStart();
}
public void postStop() {
}

59. Actor LifeCycle
59

60. Message Delivery
60
• At-Most-Once (Akka)
• At-Least-Once (Akka Persistence)
• Exactly Once
• What’s the definition of “Guaranteed Delivery”?
ActorRef Mailbox
Actor
Instance
Invokes Actor Instance with Message.
Runs on a dispatcher - abstracts threading

61. An Example
61
public class UserLoginProcessor extends UntypedActor {
LoggingAdapter log = Logging.getLogger(getContext().system(), this);
CoreUserDetailsServiceImpl coreUserDetailsService;
public UserLoginProcessor(CoreUserDetailsServiceImpl userDetailsService) {
coreUserDetailsService = userDetailsService;
}
@Override
public void onReceive(Object message) throws Exception {
if (message instanceof ProcessLoginCommand) {
SomeEvent someEvent = ((ProcessLoginCommand) message).getSomeEvent();
User user = UserDTOUtil.fromDTOToUser(someEvent.getUserDTO());
coreUserDetailsService.updateLoginTS(user);
} else if (message instance ProcessLogoutCommand) { … }
}
}
Akka Logging
non-def constructor
Command-based messaging

62. An Example
62
public class ProcessLoginCommand extends BaseCommand {
private StreamEvent streamEvent;
public ProcessLoginCommand(Object streamEvent) {
super(streamEvent);
this.streamEvent = (StreamEvent) streamEvent;
}
public StreamEvent getStreamEvent() {
return streamEvent;
}
}
public class BaseCommand<T> {
private T commandObject;
public BaseCommand(T commandObject) {
this.commandObject = commandObject;
}
public T getCommandObject() {
return commandObject;
}
}

63. An Example
63
@Autowired
private CoreUserDetailsServiceImpl userService;
@Override
public void processInboundEvent(StreamEvent event) {
switch (event.getEventType()) {
case EventType.USER_LOGIN: {
final ActorRef actorRef = actorSystemService.getActorSystem()
.actorOf(Props.create(UserLoginProcessor.class, userService), "login-processor
actorRef.tell(new ProcessLoginCommand(event), null);
…

64. An Example
64
public class UserLoginProcessor extends UntypedActor {
LoggingAdapter log = Logging.getLogger(getContext().system(),
this);
CoreUserDetailsServiceImpl coreUserDetailsService;
public UserLoginProcessor(CoreUserDetailsServiceImpl
userDetailsService) {
coreUserDetailsService = userDetailsService;
}
…
}

65. Dispatchers
65
• Control execution flow
• based on the Java Executor framework
(java.util.concurrent)
• ThreadPoolExecutor: Executes each submitted task
using thread from a predefined and configured thread
pool.
• ForkJoinPool: Same thread pool model but
supplemented with work stealing. Threads in the pool
will find and execute tasks (work stealing) created by
other active tasks or tasks allocated to other threads in
the pool that are pending execution.

66. Dispatchers
66

67. Dispatchers
67
default-dispatcher {
type = "Dispatcher"
executor = "fork-join-executor"
fork-join-executor {
parallelism-min = 8
parallelism-factor = 3.0
parallelism-max = 64
}
thread-pool-executor {
keep-alive-time = 60s
core-pool-size-min = 8
core-pool-size-factor = 3.0
core-pool-size-max = 64
max-pool-size-min = 8
max-pool-size-factor = 3.0
max-pool-size-max = 64
task-queue-size = -1
task-queue-type = "linked"
allow-core-timeout = on
…

68. Dispatcher
68

69. Pinned Dispatcher
69

70. Balancing Dispatcher
70

71. Mailbox Types
71
• Backed by queue impl. from java.util.concurrent
bounded-mailbox {
mailbox-type = "akka.dispatch.BoundedMailbox"
mailbox-capacity = 1000
}

72. Priority Mailboxes
72
public class MyPrioMailbox extends UnboundedPriorityMailbox {
// needed for reflective instantiation
public MyPrioMailbox(ActorSystem.Settings settings, Config config) {
// Create a new PriorityGenerator, lower prio means more important
super(new PriorityGenerator() {
@Override
public int gen(Object message) {
if (message.equals("highpriority"))
return 0; // 'highpriority messages should be treated first if possible
else if (message.equals("lowpriority"))
return 2; // 'lowpriority messages should be treated last if possible
else if (message.equals(PoisonPill.getInstance()))
return 3; // PoisonPill when no other left
else
return 1; // By default they go between high and low prio
}
});
}
}

73. Routers
73

74. Routers
74
• Round-Robin Router
• Random Router
• Smallest Mailbox Router
• Broadcast Router
ActorRef router = system.actorOf(new Props(MyActor.class).
withRouter(new RoundRobinRouter(nrOfInstances)),"myRouterActor");
int lowerBound = 2;
int upperBound = 15;
DefaultResizer resizer = new DefaultResizer(lowerBound, upperBound);
ActorRef randomRouter = _system.actorOf(new Props(MsgEchoActor.class). withRouter(

75. Futures
75
Blocking!
Timeout timeout = new Timeout(Duration.create(5, "seconds"));
Future<Object> future = Patterns.ask(actor, msg, timeout);
String result = (String) Await.result(future, timeout.duration());
• Callbacks: onSuccess, onFailure, onComplete
Future<Integer> future = future(new Callable<Integer>() {
public Integer call() {
return 1 / 0;
}
}, ec).recover(new Recover<Integer>() {
public Integer recover(Throwable problem) throws Throwable {
if (problem instanceof ArithmeticException)
return 0;
else
throw problem;
}
}, ec);

76. Persistence
• Experimental (from “Eventsourced”)
• Plugins: LevelDB, MongoDB, Cassandra, etc..
• Architecture:
• PersistentActor
• Journal
• AtLeastOnce Delivery
• Snapshots
76
• Event Sourcing (http://martinfowler.com/eaaDev/EventSourcing.html)
Some Code…

77. No Persistence
77
count = 0

78. No Persistence
78
count = 1
CRASH!

79. No Persistence
79
count = 0
RESTART!

80. No Persistence
80
count =1
Restarted

81. No Persistence
81
count =1
WRONG!
expected count == 2

82. With Persistence
82
Journal DB
Restarted
count =0

83. With Persistence
83
Journal DB
Restarted
count = 2

84. Example: Event-Sourcing
84

85. Event Bus
85
• Used internally by Akka: Event Stream, Dead Letters,
Logging, etc…
• Remember: No Sender access!
public boolean subscribe(Subscriber subscriber, Classifier to);
public boolean unsubscribe(Subscriber subscriber, Classifier from);
public void unsubscribe(Subscriber subscriber);
public void publish(Event event);
Some Code…

86. Stuff I didn’t cover
• Testing
• Typed Actors
• Application Monitoring
• MANY Configuration options
86
• http://doc.akka.io/docs/akka/snapshot/general/configurati
on.html

87. Questions?
87
• Beginner Examples: https://github.com/royrusso/akka-java-
examples
• Akka Java Doc:
http://doc.akka.io/docs/akka/snapshot/java.html