Click here to close now.

Welcome!

Java Authors: Yeshim Deniz, Elizabeth White, Liz McMillan, Pat Romanski, Kathy Thomas

Related Topics: Java

Java: Article

Next-Gen Concurrency in Java: The Actor Model

Multiple concurrent processes can communicate with each other without needing to use shared state variables

At a time where the clock speeds of processors have been stable over the past couple of years, and Moore's Law is instead being applied by increasing the number of processor cores, it is getting more important for applications to use concurrent processing to reduce run/response times, as the time slicing routine via increased clock speed will no longer be available to bail out slow running programs.

Carl Hewitt proposed the Actor Model in 1973 as a way to implement unbounded nondeterminism in concurrent processing. In many ways this model was influenced by the packet switching mechanism, for example, no synchronous handshake between sender and receiver, inherently concurrent message passing, messages may not arrive in the order they were sent, addresses are stored in messages, etc.

The main difference between this model and most other parallel processing systems is that it uses message passing instead of shared variables for communication between concurrent processes. Using shared memory to communicate between concurrent processes requires the application of some form of locking mechanism to coordinate between threads, which may give rise to live locks, deadlocks, race conditions and starvation.

Actors are the location transparent primitives that form the basis of the actor model. Each actor is associated with a mailbox (which is a queue with multiple producers and a single consumer) where it receives and buffers messages, and a behavior that is executed as a reaction to a message received. The messages are immutable and may be passed between actors synchronously or asynchronously depending on the type of operation being invoked. In response to a message that it receives, an actor can make local decisions, create more actors, send more messages, and designate how to respond to the next message received. Actors never share state and thus don't need to compete for locks for access to shared data.

The actor model first rose to fame in the language Erlang, designed by Ericcson in 1986. It has since been implemented in many next-generation languages on the JVM such as Scala, Groovy and Fantom. It is the simplicity of usage provided via a higher level of abstraction that makes the actor model easier to implement and reason about.

It's now possible to implement the actor model in Java, thanks to the growing number of third-party concurrency libraries advertising this feature. Akka is one such library, written in Scala, that uses the Actor model to simplify writing fault-tolerant, highly scalable applications in both Java and Scala.

Implementation
Using Akka, we shall attempt to create a concurrent processing system for loan request processing in a bank as can be seen in the Figure 1.

Figure 1

The system consists of four actors:

  1. The front desk - which shall receive loan requests from the customers and send them to the back office for processing. It shall also maintain the statistics of the number of loans accepted/rejected and print a report detailing the same on being asked to do so.
  2. The back office - which shall sort the loan requests into personal loans and home loans, and send them to the corresponding accountant for approval/rejection.
  3. The personal loan accountant - who shall process personal loan requests, including approving/rejecting the requests, carrying out credit history checks and calculating the rate of interest.
  4. The home loan accountant - who shall process home loan requests, including approving/rejecting the requests, carrying out credit history checks and calculating the rate of interest.

To get started, download the version 2.0 of Akka for Java from http://akka.io/downloads and add the jars present in ‘akka-2.0-RC4\lib' to the classpath.

Next, create a new Java class "Bank.java" and add the following import statements :

import akka.actor.ActorRef;

import akka.actor.ActorSystem;

import akka.actor.Props;

import akka.actor.UntypedActor;

import akka.routing.RoundRobinRouter;

Now, create a few static nested classes under ‘Bank' that will act as messages (DTOs) and be passed to actors.

1. ‘LoanRequest' will contain the following elements and their corresponding getters/setters:

int requestedLoan;
int
accountBalance;

2. ‘PersonalLoanRequest' will extend ‘LoanRequest' and contain the following element and its corresponding getter:

final static String type="Personal";

3. ‘HomeLoanRequest' will extend ‘LoanRequest' and contain the following element and its corresponding getter:

final static String type="Home";

4. ‘LoanReply' will contain the following elements and their corresponding getters/setters:

String type;
boolean
approved;
int
rate;

Next, create a static nested class ‘PersonalLoanAccountant' under ‘Bank'.

public static class PersonalLoanAccountant extends UntypedActor {
public
int rateCaluclation(int requestedLoan, int accountBalance) {
if
(accountBalance/requestedLoan>=2)
return
5;
else

return
6;
}

public
void checkCreditHistory() {
for
(int i=0; i<1000; i++) {
continue
;
}
}
public
void onReceive(Object message) {
if
(message instanceof PersonalLoanRequest) {
PersonalLoanRequest request=PersonalLoanRequest.class.cast(message);
LoanReply reply = new LoanReply();
reply.setType(request.getType());
if
(request.getRequestedLoan()<request.getaccountBalance()) {
reply.setApproved(true);
reply.setRate(rateCaluclation(request.getRequestedLoan(), request.getaccountBalance()));
checkCreditHistory();
}
getSender().tell(reply);
} else {
unhandled(message);
}
}
}

The above class  serves as an actor in the system. It extends the ‘UntypedActor' base class provided by Akka and must define its ‘onReceive‘ method. This method acts as the mailbox and receives messages from other actors (or non-actors) in the system. If the message received is of type 'PersonalLoanRequest', then it can be processed by approving/rejecting the loan request, setting the rate of interest and checking the requestor's credit history. Once the processing is complete, the requestor uses the sender's reference (which is embedded in the message) to send the reply (LoanReply) to the requestor via the ‘getSender().tell()' method.

Now, create a similar static nested class ‘HomeLoanAccountant' under ‘Bank'

public static class HomeLoanAccountant extends UntypedActor {
public
int rateCaluclation(int requestedLoan, int accountBalance) {
if
(accountBalance/requestedLoan>=2)
return
7;
else

return
8;
}

public
void checkCreditHistory() {
for
(int i=0; i<2000; i++) {
continue
;
}
}
public
void onReceive(Object message) {
if
(message instanceof HomeLoanRequest) {
HomeLoanRequest request=HomeLoanRequest.class.cast(message);
LoanReply reply = new LoanReply();
reply.setType(request.getType());
if
(request.getRequestedLoan()<request.getaccountBalance()) {
reply.setApproved(true);
reply.setRate(rateCaluclation(request.getRequestedLoan(), request.getaccountBalance()));
checkCreditHistory();
}
getSender().tell(reply);
} else {
unhandled(message);
}
}
}

Now, create a static nested class ‘BackOffice' under ‘Bank':

public static class BackOffice extends UntypedActor {

ActorRef personalLoanAccountant=getContext().actorOf(new Props(PersonalLoanAccountant.class).withRouter(new RoundRobinRouter(2)));
ActorRef homeLoanAccountant=getContext().actorOf(new Props(HomeLoanAccountant.class).withRouter(new RoundRobinRouter(2)));

public void onReceive(Object message) {
if
(message instanceof PersonalLoanRequest) {
personalLoanAccountant.forward(message, getContext());
} else if (message instanceof HomeLoanRequest) {
homeLoanAccountant.forward(message, getContext());
} else {
unhandled(message);
}
}

}

The above class serves as an actor in the system and is purely used to route the incoming messages to PersonalLoanAccountant or HomeLoanAccountant, based on the type of message received. It defines actor references ‘personalLoanAccountant' and ‘homeLoanAccountant' to ‘PersonalLoanAccountant.class' and ‘HomeLoanAccountant.class', respectively. Each of these references initiates two instances of the actor it refers to and attaches a round-robin router to cycle through the actor instances. The ‘onReceive' method checks the type of the message received and forwards the message to either ‘PersonalLoanAccountant' or ‘HomeLoanAccountant' based on the message type. The ‘forward()' method helps ensure that the reference of the original sender is maintained in the message, so the receiver of the message (‘PersonalLoanAccountant' or ‘HomeLoanAccountant') can directly reply back to the message's original sender.

Now, create a static nested class ‘FrontDesk' under ‘Bank':

public static class FrontDesk extends UntypedActor {
int
approvedPersonalLoans=0;
int
approvedHomeLoans=0;
int
rejectedPersonalLoans=0;
int
rejectedHomeLoans=0;

ActorRef backOffice=getContext().actorOf(
new Props(BackOffice.class), "backOffice");

public
void maintainLoanApprovalStats(Object message) {
LoanReply reply = LoanReply.class.cast(message);
if
(reply.isApproved()) {
System.out.println(reply.getType()+" Loan Approved"+" at "+reply.getRate()+"% interest.");
if
(reply.getType().equals("Personal"))
++approvedPersonalLoans;
else
if(reply.getType().equals("Home"))
++approvedHomeLoans;
} else {
System.out.println(reply.getType()+" Loan Rejected");
if
(reply.getType().equals("Personal"))
++rejectedPersonalLoans;
else
if(reply.getType().equals("Home"))
++rejectedHomeLoans;
}
}

public void printLoanApprovalStats() {
System.out.println("--- REPORT ---");
System.out.println("Personal Loans Approved : "+approvedPersonalLoans);
System.out.println("Home Loans Approved : "+approvedHomeLoans);
System.out.println("Personal Loans Rejected : "+rejectedPersonalLoans);
System.out.println("Home Loans Rejected : "+rejectedHomeLoans);
}
public
void onReceive(Object message) {
if
(message instanceof LoanRequest) {
backOffice.tell(message, getSelf());
} else if (message instanceof LoanReply) {
maintainLoanApprovalStats(message);
} else if(message instanceof String && message.equals("printLoanApprovalStats")) {
printLoanApprovalStats();
getContext().stop(getSelf());
} else {
unhandled(message);
}
}
}

The above class serves as the final actor in the system. It creates a reference ‘backOffice' to the actor ‘BackOffice.class'. If the message received is of type ‘LoanRequest', it sends the message to ‘BackOffice' via the method ‘backOffice.tell()', which takes a message and the reference to the sender (acquired through the method ‘getSelf()') as arguments. If the message received is of type ‘LoanReply', it updates the counters to maintain the approved/rejected counts. If the message received is "printLoanApprovalStats", it prints the stats stored in the counters, and then proceeds to stop itself via the method ‘getContext().stop(getSelf())'. The actors follow a pattern of supervisor hierarchy, and thus this command trickles down the hierarchy chain and stops all four actors in the system.

Finally, write a few methods under ‘Bank' to submit requests to the ‘FrontOffice':

public static void main(String[] args) throws InterruptedException {
ActorSystem system = ActorSystem.create("bankSystem");
ActorRef frontDesk = system.actorOf(new Props(FrontDesk.class), "frontDesk");
submitLoanRequests
(frontDesk);
Thread.sleep(1000);
printLoanApprovalStats
(frontDesk);
system.shutdown();
}

public
static PersonalLoanRequest getPersonalLoanRequest() {
int
min=10000; int max=50000;
int
amount=min + (int)(Math.random() * ((max - min) + 1));
int
balance=min + (int)(Math.random() * ((max - min) + 1));
return
(new Bank()).new PersonalLoanRequest(amount, balance);
}

public
static HomeLoanRequest getHomeLoanRequest() {
int
min=50000; int max=90000;
int
amount=min + (int)(Math.random() * ((max - min) + 1));
int
balance=min + (int)(Math.random() * ((max - min) + 1));
return
(new Bank()).new HomeLoanRequest(amount, balance);
}

public static void submitLoanRequests(ActorRef frontDesk) {
for
(int i=0;i<1000;i++) {
frontDesk.tell(getPersonalLoanRequest());
frontDesk.tell(getHomeLoanRequest());
}
}

public static void printLoanApprovalStats(ActorRef frontDesk) {
frontDesk.tell("printLoanApprovalStats");
}

The method ‘main' creates an actor system ‘system' using the method ‘ActorSystem.create()'. It then creates a reference ‘frontDesk' to the actor ‘FrontDesk.class'. It uses this reference to send a 1000 requests each of types ‘PersonalLoanRequest' and ‘HomeLoanRequest' to ‘FrontDesk'. It then sleeps for a second, following which it sends the message "printLoanApprovalStats" to ‘FrontDesk'. Once done, it shuts down the actor system via the method ‘system.shutdown()'.

Conclusion
Running the above code will create a loan request processing system with concurrent processing capabilities, and all this without using a single synchronize/lock pattern. Moreover, the code doesn't need one to go into the low-level semantics of the JVM threading mechanism or use the complex ‘java.util.concurrent' package. This mechanism of concurrent processing using the Actor Model is truly more robust as multiple concurrent processes can communicate with each other without needing to use shared state variables.

More Stories By Sanat Vij

Sanat Vij is a professional software engineer currently working at CenturyLink. He has vast experience in developing high availability applications, configuring application servers, JVM profiling and memory management. He specializes in performance tuning of applications, reducing response times, and increasing stability.

Comments (0)

Share your thoughts on this story.

Add your comment
You must be signed in to add a comment. Sign-in | Register

In accordance with our Comment Policy, we encourage comments that are on topic, relevant and to-the-point. We will remove comments that include profanity, personal attacks, racial slurs, threats of violence, or other inappropriate material that violates our Terms and Conditions, and will block users who make repeated violations. We ask all readers to expect diversity of opinion and to treat one another with dignity and respect.


@ThingsExpo Stories
In the consumer IoT, everything is new, and the IT world of bits and bytes holds sway. But industrial and commercial realms encompass operational technology (OT) that has been around for 25 or 50 years. This grittier, pre-IP, more hands-on world has much to gain from Industrial IoT (IIoT) applications and principles. But adding sensors and wireless connectivity won’t work in environments that demand unwavering reliability and performance. In his session at @ThingsExpo, Ron Sege, CEO of Echelon, will discuss how as enterprise IT embraces other IoT-related technology trends, enterprises with i...
Enthusiasm for the Internet of Things has reached an all-time high. In 2013 alone, venture capitalists spent more than $1 billion dollars investing in the IoT space. With "smart" appliances and devices, IoT covers wearable smart devices, cloud services to hardware companies. Nest, a Google company, detects temperatures inside homes and automatically adjusts it by tracking its user's habit. These technologies are quickly developing and with it come challenges such as bridging infrastructure gaps, abiding by privacy concerns and making the concept a reality. These challenges can't be addressed w...
We’re no longer looking to the future for the IoT wave. It’s no longer a distant dream but a reality that has arrived. It’s now time to make sure the industry is in alignment to meet the IoT growing pains – cooperate and collaborate as well as innovate. In his session at @ThingsExpo, Jim Hunter, Chief Scientist & Technology Evangelist at Greenwave Systems, will examine the key ingredients to IoT success and identify solutions to challenges the industry is facing. The deep industry expertise behind this presentation will provide attendees with a leading edge view of rapidly emerging IoT oppor...
The industrial software market has treated data with the mentality of “collect everything now, worry about how to use it later.” We now find ourselves buried in data, with the pervasive connectivity of the (Industrial) Internet of Things only piling on more numbers. There’s too much data and not enough information. In his session at @ThingsExpo, Bob Gates, Global Marketing Director, GE’s Intelligent Platforms business, to discuss how realizing the power of IoT, software developers are now focused on understanding how industrial data can create intelligence for industrial operations. Imagine ...
SYS-CON Events announced today that Liaison Technologies, a leading provider of data management and integration cloud services and solutions, has been named "Silver Sponsor" of SYS-CON's 16th International Cloud Expo®, which will take place on June 9-11, 2015, at the Javits Center in New York, NY. Liaison Technologies is a recognized market leader in providing cloud-enabled data integration and data management solutions to break down complex information barriers, enabling enterprises to make smarter decisions, faster.
The 17th International Cloud Expo has announced that its Call for Papers is open. 17th International Cloud Expo, to be held November 3-5, 2015, at the Santa Clara Convention Center in Santa Clara, CA, brings together Cloud Computing, APM, APIs, Microservices, Security, Big Data, Internet of Things, DevOps and WebRTC to one location. With cloud computing driving a higher percentage of enterprise IT budgets every year, it becomes increasingly important to plant your flag in this fast-expanding business opportunity. Submit your speaking proposal today!
Collecting data in the field and configuring multitudes of unique devices is a time-consuming, labor-intensive process that can stretch IT resources. Horan & Bird [H&B], Australia’s fifth-largest Solar Panel Installer, wanted to automate sensor data collection and monitoring from its solar panels and integrate the data with its business and marketing systems. After data was collected and structured, two major areas needed to be addressed: improving developer workflows and extending access to a business application to multiple users (multi-tenancy). Docker, a container technology, was used to ...
Hadoop as a Service (as offered by handful of niche vendors now) is a cloud computing solution that makes medium and large-scale data processing accessible, easy, fast and inexpensive. In his session at Big Data Expo, Kumar Ramamurthy, Vice President and Chief Technologist, EIM & Big Data, at Virtusa, will discuss how this is achieved by eliminating the operational challenges of running Hadoop, so one can focus on business growth. The fragmented Hadoop distribution world and various PaaS solutions that provide a Hadoop flavor either make choices for customers very flexible in the name of opti...
For years, we’ve relied too heavily on individual network functions or simplistic cloud controllers. However, they are no longer enough for today’s modern cloud data center. Businesses need a comprehensive platform architecture in order to deliver a complete networking suite for IoT environment based on OpenStack. In his session at @ThingsExpo, Dhiraj Sehgal from PLUMgrid will discuss what a holistic networking solution should really entail, and how to build a complete platform that is scalable, secure, agile and automated.
With major technology companies and startups seriously embracing IoT strategies, now is the perfect time to attend @ThingsExpo in Silicon Valley. Learn what is going on, contribute to the discussions, and ensure that your enterprise is as "IoT-Ready" as it can be! Internet of @ThingsExpo, taking place Nov 3-5, 2015, at the Santa Clara Convention Center in Santa Clara, CA, is co-located with 17th Cloud Expo and will feature technical sessions from a rock star conference faculty and the leading industry players in the world. The Internet of Things (IoT) is the most profound change in personal an...
All major researchers estimate there will be tens of billions devices - computers, smartphones, tablets, and sensors - connected to the Internet by 2020. This number will continue to grow at a rapid pace for the next several decades. With major technology companies and startups seriously embracing IoT strategies, now is the perfect time to attend @ThingsExpo, June 9-11, 2015, at the Javits Center in New York City. Learn what is going on, contribute to the discussions, and ensure that your enterprise is as "IoT-Ready" as it can be
Wearable devices have come of age. The primary applications of wearables so far have been "the Quantified Self" or the tracking of one's fitness and health status. We propose the evolution of wearables into social and emotional communication devices. Our BE(tm) sensor uses light to visualize the skin conductance response. Our sensors are very inexpensive and can be massively distributed to audiences or groups of any size, in order to gauge reactions to performances, video, or any kind of presentation. In her session at @ThingsExpo, Jocelyn Scheirer, CEO & Founder of Bionolux, will discuss ho...
The true value of the Internet of Things (IoT) lies not just in the data, but through the services that protect the data, perform the analysis and present findings in a usable way. With many IoT elements rooted in traditional IT components, Big Data and IoT isn’t just a play for enterprise. In fact, the IoT presents SMBs with the prospect of launching entirely new activities and exploring innovative areas. CompTIA research identifies several areas where IoT is expected to have the greatest impact.
The 4th International Internet of @ThingsExpo, co-located with the 17th International Cloud Expo - to be held November 3-5, 2015, at the Santa Clara Convention Center in Santa Clara, CA - announces that its Call for Papers is open. The Internet of Things (IoT) is the biggest idea since the creation of the Worldwide Web more than 20 years ago.
Every day we read jaw-dropping stats on the explosion of data. We allocate significant resources to harness and better understand it. We build businesses around it. But we’ve only just begun. For big payoffs in Big Data, CIOs are turning to cognitive computing. Cognitive computing’s ability to securely extract insights, understand natural language, and get smarter each time it’s used is the next, logical step for Big Data.
There's no doubt that the Internet of Things is driving the next wave of innovation. Google has spent billions over the past few months vacuuming up companies that specialize in smart appliances and machine learning. Already, Philips light bulbs, Audi automobiles, and Samsung washers and dryers can communicate with and be controlled from mobile devices. To take advantage of the opportunities the Internet of Things brings to your business, you'll want to start preparing now.
17th Cloud Expo, taking place Nov 3-5, 2015, at the Santa Clara Convention Center in Santa Clara, CA, will feature technical sessions from a rock star conference faculty and the leading industry players in the world. Cloud computing is now being embraced by a majority of enterprises of all sizes. Yesterday's debate about public vs. private has transformed into the reality of hybrid cloud: a recent survey shows that 74% of enterprises have a hybrid cloud strategy. Meanwhile, 94% of enterprises are using some form of XaaS – software, platform, and infrastructure as a service.
P2P RTC will impact the landscape of communications, shifting from traditional telephony style communications models to OTT (Over-The-Top) cloud assisted & PaaS (Platform as a Service) communication services. The P2P shift will impact many areas of our lives, from mobile communication, human interactive web services, RTC and telephony infrastructure, user federation, security and privacy implications, business costs, and scalability. In his session at @ThingsExpo, Robin Raymond, Chief Architect at Hookflash, will walk through the shifting landscape of traditional telephone and voice services ...
Explosive growth in connected devices. Enormous amounts of data for collection and analysis. Critical use of data for split-second decision making and actionable information. All three are factors in making the Internet of Things a reality. Yet, any one factor would have an IT organization pondering its infrastructure strategy. How should your organization enhance its IT framework to enable an Internet of Things implementation? In his session at Internet of @ThingsExpo, James Kirkland, Chief Architect for the Internet of Things and Intelligent Systems at Red Hat, described how to revolutioniz...
For IoT to grow as quickly as analyst firms’ project, a lot is going to fall on developers to quickly bring applications to market. But the lack of a standard development platform threatens to slow growth and make application development more time consuming and costly, much like we’ve seen in the mobile space. In his session at @ThingsExpo, Mike Weiner is Product Manager of the Omega DevCloud with KORE Telematics Inc., will discuss the evolving requirements for developers as IoT matures and conduct a live demonstration of how quickly application development can happen when the need to comply...