Scribd
Upload
918 views

Akka

Akka is an open-source toolkit for building distributed, fault-tolerant applications using the actor model. It provides features like concurrency through actors, scalability, fault tolerance through supervision strategies, and location transparency. Actors are the fundamental unit of computation in Akka and communicate asynchronously by message passing without shared state. Akka supports Java and Scala APIs and actors can be created in hierarchies and made remote. Routing and testing capabilities are also provided.

Uploaded by

anilkd11
Copyright
© © All Rights Reserved
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
918 views

Akka

Akka is an open-source toolkit for building distributed, fault-tolerant applications using the actor model. It provides features like concurrency through actors, scalability, fault tolerance through supervision strategies, and location transparency. Actors are the fundamental unit of computation in Akka and communicate asynchronously by message passing without shared state. Akka supports Java and Scala APIs and actors can be created in hierarchies and made remote. Routing and testing capabilities are also provided.

Uploaded by

anilkd11
Copyright
© © All Rights Reserved
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
You are on page 1/ 15

Akka

Anil Dhulipalla

what is Akka?
Akka is an open-source toolkit and runtime to build concurrent, distributed, fault tolerant applications.
Akka provides the following features

Concurrency through Actor Model system


Scales up(concurrency) and out(distributed)
Fault tolerance The supervision strategy helps to recover actors for exceptions.
Event Driven Architecture
Transaction support
Location Transparency
Scala/Java API.

Key Constructs of AKka

Installation
Akka Actor
<dependency>
<groupId>com.typesafe.akka</groupId>
<artifactId>akka-actor_2.10</artifactId>
<version>2.3-M1</version>
</dependency>

Akka Test Kit


<dependency>
<groupId>com.typesafe.akka</groupId>
<artifactId>akka-testkit_2.10</artifactId>
<version>2.3-M1</version>
</dependency>

Actor Model
Actors instead of Objects
No shared state between actors
Asynchronous message passing

Actors

Fundamental unit of Computation


Behavior React on messages it receives
State- No need for synchronization.
Interaction- interact with other Actors via Messages
Isolated, Lightweight than a thread, Asynchronous, Non-blocking
Messages are kept in mail box and processed in order
Messaging model of an Actor

Define Actor
public class CheckOutChildActor extends UntypedActor {
private static final Logger LOG = Logger.getLogger(CheckOutChildActor.class);
public CheckOutChildActor() throws DatabaseException, ConfigurationException{
this.checkoutBasicService = new CheckoutBasicService();
}
@Override
public void preStart() {
LOG.info("Starting CheckOutChildActor instance hashcode # {} -" + this.hashCode());
}
@Override
public void onReceive(Object o) throws Exception {
try {
if (o instanceof Checkout) {
Checkout checkout = (Checkout) o;
CheckoutDTO checkoutDTO = checkoutBasicService.getCheckout(checkout);
getSender().tell(checkoutDTO, getSelf());
} else {
unhandled(o);
}
} catch (IncompleteCheckoutException e) {
getSender().tell(new Status.Success(e), getSelf());
throw e;
} catch (DatabaseException e) {
getSender().tell(new Status.Failure(e), getSelf());
throw e;
} catch (CustomException e) {
getSender().tell(new Status.Failure(e), getSelf());
throw e;
}catch (Exception e) {
LOG.error("CHILD ERROR",e);
getSender().tell(new Status.Failure(e), getSelf());
throw e;
}
}
@Override
public void postStop() {
LOG.info("Stopping CheckOutChildActor instance hashcode # {} -" + this.hashCode());
}
}

Create and send message


//Creating an Actor system
ActorSystem actorSystem= ActorSystem.create(name, ConfigFactory.load().getConfig(dispatcher));
//Creating top level Actor
ActorRef masterActorRef= actorSystem.actorOf(Props.create(CheckOutChildActor.class).withRouter(new
RoundRobinPool(20)));
//Model-1
//In this model you send a message to the Actor and dont wait for response from it.
masterActorRef.tell(Hello World, getSelf());
//Model-2
final Timeout timeout = new Timeout(Duration.create(120,
TimeUnit.SECONDS));
Future<Object> future = Patterns.ask(masterActorRef, message, timeout);
Object resultObject = Await.result(future, Duration.Inf());

Actor system

can create Hierarchy of actors

//Creating top level Actor


ActorRef masterActorRef=
actorSystem.actorOf(Props.create(CheckOutMast
erActor.class).withRouter(new
RoundRobinPool(20)));
//Creating a child actor in Master Actor
ActorRef childActorRef=
getContext().actorOf(Props.create(CheckOutChi
ldActor.class));

Fault Tolerance in Akka

STOPPED- Terminate the


subordinate actor
RESTARTED-Kill the current actor
instance and instantiate a new actor
instance.
RESUMED-Keep the current state
ESCALATED-Escalate the failure to
its own supervisor.

Fault Tolerance in Akka


public class CheckOutMasterActor extends UntypedActor {
/**
* Supervisor strategy to handle exceptions thrown by child actors
*/
private SupervisorStrategy strategy = new AllForOneStrategy(10,
Duration.Inf(), new Function<Throwable, SupervisorStrategy.Directive>() {
public SupervisorStrategy.Directive apply(Throwable t) {
if (t instanceof IncompleteCheckoutException) {
return SupervisorStrategy.resume();
} else {
return SupervisorStrategy.escalate();
}
}
});
//This method need to be overridden for Supervisor strategy
@Override
public SupervisorStrategy supervisorStrategy() {
return strategy;
}
}

Remote Actor

Actors are location transparent and distributed by design


Actors can be made remote through config
Messages are serialized using java serialization.

Routing
A router routes incoming messages to outbound actors

RoundRobinPool
SmallestMailboxPool
RandomPool
ScatterGatherFirstCompletedPool
BroadcastPool

private ActorRef getMasterActorFromPool() {


if (checkoutMasterActorPool == null) {
propsMaster = Props.create(masterActorClass)
.withRouter(new SmallestMailboxPool(AKKA_MASTER_ROUTER_SIZE));
checkoutMasterActorPool =
AkkaManager.getInstance().getActorSystem().actorOf(propsMaster, "MasterActorPool");
}
return checkoutMasterActorPool;
}

Unit Testing
public class CheckOutChildActorTest extends TestKit {
private static ActorSystem actorSystem = ActorSystem.create("childActorTestKit");
private TestActorRef<CheckOutChildActor> childActorRef;
@Mock
private CheckoutBasicService checkoutBasicService;
@InjectMocks
private CheckOutChildActor checkOutChildActor;
public CheckOutChildActorTest() {
super(actorSystem);
}
@Before
public void setUp() throws Exception {
System.setProperty("user.home", System.getProperty("user.dir") + "/src/test/resources");

childActorRef = TestActorRef.apply(Props.create(CheckOutChildActor.class),
actorSystem);
checkOutChildActor = childActorRef.underlyingActor();
MockitoAnnotations.initMocks(this);
}
@After
public void tearDown() throws Exception {
}
@Test
public void testChildActor() throws Exception {
Checkout checkout = CheckoutGenerator.generateCheckout(2L);
CheckoutDTO checkoutDTO = CheckoutGenerator.generateCheckoutDTO(2L, 2L);

Thank You

You might also like