|
|
Recommended: Sing it, brah! 5 fabulous songs for developers
JW's Top 5
Featured White Papers
- Measuring Risk to Improve Java Software Quality
- Do You Really Get Classloaders?
- Pragmatic Continuous Delivery with Jenkins, Nexus, and LiveRebel
- Your Next Java Web App: Less XML, No Long Restarts, Fewer Hassles
- Coding with JRebel, Java Forever Changed
- 2012 Developer Productivity Report: Java Tools, Tech, Devs, and Data
Sponsored Links
-
Graph databases are 1000x faster than relational.
Learn More!
-
Career opportunities at Harman- Careers That'll Rock Your Socks Off.
Learn More!
-
Developer-friendly Java PDF libraries by Qoppa Software
Live Demos
-
Stop blaming your app! Diagnose Java performance issues.
Free tool >
-
UrbanCode: Go From Continuous Integration to
Continuous DeliveryLearn More!
Sponsored Links
Optimize with a SATA RAID Storage Solution
Range of capacities as low as $1250 per TB. Ideal if you currently rely on servers/disks/JBODs
Understanding actor concurrency, Part 2: Actors on the JVM
Actor concurrency libraries for Scala, Groovy, and Java
In the first half of his introduction to actor concurrency, Alex Miller discussed the limitations of shared-state concurrency and explained how the actor model is expressed in Erlang. While Erlang is a nonstarter for many shops, actor implementations do exist for languages that run on the JVM. Find out how actors work and see them implemented using Scala's standard library, Groovy's GParallelizer, and the Java libraries Kilim, ActorFoundry, Actors Guild, and Jetlang.
In my previous article I introduced you to the advantages of the actor concurrency model over the shared-stated model used by popular imperative languages like Java. To help you understand actor concurrency, I explained how it's implemented in Erlang, a functional language that has been around for a couple of decades. Erlang's implementation is elegant, but it's a nonstarter if you're committed to developing applications in a language that runs on the JVM. So, in this article I'll look at Erlang-inspired actor implementations in three JVM languages: Scala, Groovy, and Java.
Table 1 is an overview of the languages and actor libraries I'll discuss in this article.
Listing 1. Actor libraries on the JVM
| Language | Library | Weaving strategy |
|---|---|---|
| Scala 2.7.3 | Scala API | n/a |
| Groovy 1.6 | GParallelizer 0.6 | n/a |
| Java | Kilim 0.6 | compile-time |
| Java | ActorFoundry 1.0 | compile-time |
| Java | Actors Guild 0.6 | runtime |
| Java | Jetlang 0.1.7 | n/a |
I'll use the schoolyard game Rock-Paper-Scissors as a reference application and implement it in each library to demonstrate the features and differences. (You can download the source code anytime.) Each implementation uses two Player actors and a Coordinator actor. The Coordinator requests each player to play, and each Player replies with Rock, Paper, or Scissors. The Coordinator accepts the responses, announces the winner, and starts over. The message flow is illustrated in Figure 1.
Figure 1. Rock-Paper-Scissors message flow
Actors in Scala
Scala features the most faithful implementation of the Erlang actor model on the JVM and has made it a central part of Scala's concurrency story. Scala is a hybrid language that takes cues from both the object-oriented and functional programming traditions. It is designed to be extensible and to grow into new language features as needed. The language itself is built on a small core of principles, but it has a much larger perceived surface area thanks to these "scalable" language capabilities.
In fact, the Scala actors implementation is provided as part of the Scala standard library (equivalent to the JDK in Java), not as part of the language. It replicates much of the Erlang actor model. The fact that this is possible to do well as a library is a testament to Scala's flexibility.
Scala actors support all of the key concepts from Erlang. Actors are defined as a trait in the Scala standard library. In Scala, a trait is a set of method and field definitions that can be mixed into other classes. This is similar to providing an abstract superclass in Java but more flexible, particularly in comparison to multiple inheritance.
- Feedback
More from JavaWorld
Resources
- Download the source code for examples in this article.
- More about concurrency:
- Recent JavaWorld articles addressing concurrency include "Understanding actor concurrency, Part 1" (Alex Miller, January 2009) and "Java concurrency with thread gates (Obi Ezechukwu, JavaWorld, March 2009); see JW's Threads & Concurrency index for more.
- "Want Erlang concurrency but are stuck with Java: 4 Alternatives (+1)" (Stephan Schmidt, Code Monkeyism, January 2009) discusses concurrency solutions for Java. Also see "Concurrency Rant: Different Types of Concurrency and Why Lots of People Already use 'Erlang' Concurrency" (Stephan Schmidt, Code Monkeyism, December 2008).
- "More Java Actor Frameworks Compared" (Sujit Pal, Salmon Run, January 2009) further discusses some of the actor libraries introduced in this article.
- Also see Alex Miller's links to interesting concurrency articles on Tumblr.
- Scala:
- Both Ted Neward and Bill Venners have discussed the importance of Scala for concurrency programming in JavaWorld podcasts.
- Take a walkthrough of some complete programs that implement the Scala Actors library in Scala Actors: A Short Tutorial.
- Learn more about Scala actors in "Scala Actors 101 - Threadless and Scalable" (DZone, Debasish Ghosh, August 2008).
- The research paper "Actors that Unify Threads and Events" (Philipp Haller and Martin Odersky, LAMP-REPORT-2007-001) presents an actors abstraction that combines the benefits of thread-based and event-based concurrency.
- The blog post "Learning Scala for its Actors" (Sujit Pal, Salmon Run, December 2008) recounts the writer's foray into learning and using the Scala Actors library.
- "Real-World Scala: Fault-tolerant Concurrent Asynchronous Components" (Jonas Bonér, December 2008) discusses Scala OTP.
- "Clustering Scala Actors with Terracotta" (Jonas Bonér, January 2008) discusses scaling Scala actors with Terracotta.
- GParallelizer:
- Visit the GParallelizer project site and read about Actors on the project wiki.
- Check out "Actors in Groovy - concurrency the easy way with GParallelizer" (Václav Pech, JRoller, January 2009) and a follow-up, "Event-based actors in Groovy" (March 2009).
- Kilim:
- Visit the Kilim project site.
- In "Concurrency, Actors and Kilim" (Sujit Pal, Salmon Run, December 2008), a Kilim neophyte codes up a simple hypothetical system.
- "Interesting picture: Benchmarking Erlang versus Java concurrency" (Stephan Schmidt, Code Monkeyism, June 2008) compares actors in Java to actors in Erlang.
- ActorFoundry:
- Visit the ActorFoundry site.
- Actors Guild:
- Visit the Actors Guild framework project site.
- Check out this Actors Guild tutorial.
- Jetlang:
- Visit the Jetlang project home.
- In "Java Concurrency with Jetlang Actors" (Sujit Pal, Salmon Run, December 2008), the author rewrites his previous Kilim example with Jetlang.
- "Scala Actors vs. Jetlang" (Mike Rettig's Weblog, December 2008) implements a Scala example in Jetlang to highlight the differences and similarities. Rettig is the author of the Jetlang project.
- "Distributed Messaging with Jetlang and Terracotta" (Mike Rettig's Weblog, August 2008) links to example code by Taylor Gautier showing how to integrate Terracotta and Jetlang.
More from JavaWorld
- See the JavaWorld Site Map for a complete listing of research centers focused on client-side, enterprise, and core Java development tools and topics.
- JavaWorld's Java Technology Insider is a podcast series that lets you learn from Java technology experts on your way to work.
- Network World's IT Product Guides offer side-by-side comparison of hundreds of products in over 50 categories.
About Us | Advertise | Contact Us | Terms of Service/Privacy | AdChoices
Copyright, 2006-2013 Infoworld, Inc. All rights reserved.