AKKA Even Driven Framework Documents

AKKA Feautres:

Features Open source API & Doc availability

Supported YES YES, BOTH

Comments

JAVA & Scall API & Documentation

Approach

Event Driven Aynchronous Call

Better than thread, lock & non Blocking IO Call approach

Who is Using When to Use

LinkedIn, CSC, GILT etc Any system that have the 1. Concurrency & Parralel

need for high-throughput and Programming low latency is a good candidate for using Akka. 2. Asynchronouos Messaging & handling

3.Asynchronous Web Service services with configurable endpoints.

3. Event Based Handling better than traditional Threads & non blocking call 4. Monitoring & Supervisory programanage service failures (Supervisors), load management (back-off strategies, timeouts and processing-isolation) 5. both horizontal and vertical scalability (add more cores and/or add more machines) 6. Real-time traffic information field (traffic as in cars on highways), distributed over several nodes, 7 integrating messages between several parties, reliable backend systems. 8. For modeling and implementing complex

message flows Concurrency & Parrel Programming Support YES, (approximately 2.7 million actors per GB RAM). Using diffrrent ACTORS classes, which are light Weight than threads & Non Blocking call Event Managament YES Can Cacel ,restart, reschedule all Child task by using parent Actor using a single command Transactions using STM YES Rather than working with threads and locks by hand, transactional memory lets you atomically modify the state of many objects at once, reverting all your changes if the transaction fails. Scalability Yes, 1. Scale up (Concurrency) 2. Scale out (Remoting) 3. Fault tolerance( Distributed App) Multiple server, Can serve millions compare to thousands request using asynchronous message passing mechanism. We might run several million Actors -- quite a step up from mere thousands of threads in a traditional Java application.

Threads Fault-tolerance YES, Using asynchronous message passing mechanism A supervisor is responsible for monitoring its child Actors and restarting them when necessary. Transparent Remoting & distributed Support YES using Remote Actor .Akka's Remote Actors provide a high-performance and transparent distributed programming model. Actors running on remote nodes look just like those running locally.

Use Cases For Considering Akka: Transaction processing (online gaming, finance, statistics, betting, social media, telecom, ...) scale up, scale out, fault-tolerance / HA

Service backend (any industry, any app)

1. act as message hub / integration layer 2. service REST, SOAP, cometd etc 3. scale up, scale out, fault-tolerance / HA

Snap-in concurrency/parallelism ( any app )

Simple to work with and understand

Just add the jars to your existing JVM project (use Scala, Java, Groovy or JRuby) Batch processing ( any industry ) 1. Camel integration to hook up with batch data sources 2. Actors divide and conquer the batch workloads Communications hub ( telecom, web media, mobile media ) Game server (online gaming, betting) scale up, scale out, fault-tolerance / HA scale up, scale out, fault-tolerance / HA

BI/datamining/general purpose crunching

scale up, scale out, fault-tolerance / HA

An example of how we is it would be on a priority queue of debit/credit card transactions. We have millions of these and the effort of the work depends on the input string type. If the transaction is of type CHECK we have very little processing but if it is a point of sale then their is lots to do such as merge with meta data (category, label, tags, etc) and provide services (email/sms alerts, fraud detection, low funds balance, etc). Based on the input type we mixin the traits necessary to handle the job and then perform the work. All of these jobs come into the same queue realtime from different financial institution. Once the data is cleansed it is sent to different data stores for persistence, analytics, or pushed to a socket connection, or Lift comet actor. Working stealing actors are constantly self load balancing the work so that we can process the data as fast as possible. We can also snap in additional services, persistence models, and STM for critical decision points. The Erlang OTP style message passing on the

JVM makes a great system for developing realtime systems on the shoulders of existing libraries and application servers. Akka allows you to do message passing like you would in a traditional ESB but with speed! It also gives you tools in the framework to manage the vast amount of actor pools, remote nodes, and fault tolerance that you need for your solution.

AKKA Java API To Classes & Interface Actors Actors give you: 1. Simple and high-level abstractions for concurrency and parallelism. 2. Asynchronous, nonblocking and highly performant eventdriven programming model. 3. Very lightweight event-driven processes (approximately 2.7 million actors per GB RAM). Event Bus 1. (approximately 2.7 million actors per GB RAM). 2. One of the big
advantages is the ease at which you can compose a system out of actors and messages with almost no boilerplating, it scales extremely well without all the complexities of handrolled threading and you get asynchronous message passing between objects almost for free.

Scheduler

Futures

Fault Tolerance

Using Supervisor hierarchies.

Using Supervisor hierarchies can span over multiple JVMs to provide truly fault-tolerant systems.

Dispatchers

Routing

Remoting

AGENT

Transectors

Transactors combine actors and STM (Software Transactional Memory) into transactional actors.

It allows you to compose atomic message flows with automatic retry and rollback.

Serialization

Logger Location Transparency Everything in Akka is designed to work in a distributed environment: All interactions of actors use purely message passing and everything is asynchronous.

AKKA Introduction : 1. Open Source Event Driven Middle Driven Framework, Java & Scala API available, can interrogate with Spring & Maven 2. Akka: Akka is an event-driven middleware framework, implemented in Scala. 3. Akka is used for building high performance and reliable distributed applications. 4. Akka decouples business logic from low-level mechanisms such as threads, locks and non-blocking IO. 5. Your Scala or Java program logic lives in lightweight Actor objects which send and receive messages. 6. With Akka, you can easily configure how Actors will be created, destroyed, scheduled, and restarted upon failure.