InfoQ

News

Parallelism with Fork/Join in Java 7

Posted by R.J. Lorimer on Mar 21, 2008 03:09 PM

Community
Java
Topics
Programming ,
JCP Standards ,
Performance & Scalability
Tags
JCP ,
Concurrency ,
Closures
As the number of processor cores available on modern hardware increases, it's becoming ever more important for developers to develop in ways that take advantage of the new hardware. IBM Developerworks has posted a multi-part series on the Fork-Join concurrency library, which is shipping as part of the upcoming Java 7 release. InfoQ covered the initial fork/join proposal for Java 7 previously, with feedback from the original author, Doug Lea. The concept of fork/join with respect to Java was originally introduced by Doug Lea in his paper 'Fork/Join Parallelism in Java'. His util.concurrent package was the foundation of JSR-166, which was the java.util.concurrent library released in Java 5. Fork/Join is simply a revision of this JSR.

Part 1 of the series details the central concepts of the fork-join library, and the problem it attempts to solve:
Going forward, the hardware trend is clear; Moore’s Law will not be delivering higher clock rates, but instead delivering more cores per chip. It is easy to imagine how you can keep a dozen processors busy using a coarse-grained task boundary such as a user request, but this technique will not scale to thousands of processors — traffic may scale exponentially for short periods of time, but eventually the hardware trend wins out. As we enter the many-core era, we will need to find finer-grained parallelism or risk keeping processors idle even though there is plenty of work to do. As the dominant hardware platform shifts, so too must the software platform if we wish to keep up. To this end, Java 7 will include a framework for representing a certain class of finer-grained parallel algorithms: the fork-join framework.
Part 2 expands upon the concepts defined in part 1, referencing the divide-and-conquer programming technique:
Fork-join embodies the technique of divide-and-conquer; take a problem and recursively break it down into subproblems until the subproblems are small enough that they can be more effectively solved sequentially. The recursive step involves dividing a problem into two or more subproblems, queueing the subproblems for solution (the fork step), waiting for the results of the subproblems (the join step), and merging the results.
The article then shows an example of the merge-sort algorithm using fork/join.

The last component covered in this series is the ParallelArray class. ParallelArray is a fork/join-enabled data structure that provides a general-purpose API for performing searching, filtering, and transforming on data sets in a highly concurrent manner.

The team working on the BGGA Closures proposal for Java have adapted the fork-join framework to work with closures, and have a working implementation on their proposal site. This Developerworks article series shows two examples of using the ParallelArray class - one without the closures proposal, and one with:

Here is an example of searching for a max GPA in a group of students using the current Java 7 fork/join proposal:
ParallelArray students = new ParallelArray(fjPool, data);
double bestGpa = students.withFilter(isSenior)
.withMapping(selectGpa)
.max();

public class Student {
String name;
int graduationYear;
double gpa;
}

static final Ops.Predicate isSenior = new Ops.Predicate() {
public boolean op(Student s) {
return s.graduationYear == Student.THIS_YEAR;
}
};

static final Ops.ObjectToDouble selectGpa = new Ops.ObjectToDouble() {
public double op(Student student) {
return student.gpa;
}
};


Here is the same example using the BGGA Closures proposal:


double bestGpa = students.withFilter({Student s => (s.graduationYear == THIS_YEAR) })
.withMapping({ Student s => s.gpa })
.max();

Currently, Java 7 is expected for an early 2009 release.

5 comments

Reply

API or Language Extensions? by Per Olesen Posted Mar 22, 2008 3:10 AM
Re: API or Language Extensions? by Ilya Sterin Posted Mar 22, 2008 12:51 PM
closures, when? by serge boulay Posted Mar 22, 2008 2:55 PM
Articles by Brian Goetz by Matt Passell Posted Mar 22, 2008 9:50 PM
Grid Enabled Fork/Join by Dmitriy Setrakyan Posted Mar 24, 2008 6:45 PM
  1. Back to top

    API or Language Extensions?

    Mar 22, 2008 3:10 AM by Per Olesen

    It is nice and interesting, that Java is coming with new concurrency constructs in APIs. But there are many out there (all the Erlang folks, e.g.), that think we are in need of a language, where the concurrency support is built into the language. Erlang is such a language, but I really do not think Erlang to become a widespread language, like Java is.



    Does anyone know of ongoing work somewhere, to extend Java with language constructs, that enable easy use of multicore CPUs? That is, language constructs, not merely new APIs and frameworks.




    Tech Per




  2. Back to top

    Re: API or Language Extensions?

    Mar 22, 2008 12:51 PM by Ilya Sterin

    Yes, take a look at scala.

  3. Back to top

    closures, when?

    Mar 22, 2008 2:55 PM by serge boulay

    I don't think we will be seeing any of this anytime soon. Especially the closure stuff, take a look at Neil Gafter's presentation from qCon, I suspect closures won't even be in java 7 (bgga). It looks like java 8 now, unless I missed something That means you'll be able to use the closure example in about 5 years. I think I need to start looking at Scala.


    www.eos1.dk/qcon-london-2008/slides/NealGafter_...

  4. Back to top

    Articles by Brian Goetz

    Mar 22, 2008 9:50 PM by Matt Passell

    The announcement above fails to mention that the author of these articles on IBM DeveloperWorks is Brian Goetz, lead author of the book Java Concurrency in Practice. Just thought I'd include that tidbit.

  5. Back to top

    Grid Enabled Fork/Join

    Mar 24, 2008 6:45 PM by Dmitriy Setrakyan

    I am hoping this proposal actually makes it into Java 7.
    <p>
    GridGain has been providing fork/join type of processing on the Grid for ages, so once this proposal is out, we will make sure to grid-enable it right away ;-)
    <p>
    Also, I particularly like the proposed "work stealing" paradigm within local JVM, as it also has a direct application on the grid. We have implemented this paradigm on the grid (we call it job stealing) where underloaded nodes steal jobs from overloaded nodes to provide even load distribution across grid nodes (you can see docs on the Wiki here).
    <p>
    Best,

    Dmitriy Setrakyan

    GridGain - Grid Computing Made Simple

    </p></p></p>

Exclusive Content

Ruby.rewrite(Ruby)

In this RubyFringe talk, Reginald Braithwaite writes Ruby code to read, write, and rewrite Ruby. Demos include extending Ruby with conditional expressions, call-by-name and more.

Book Except and Interview : Aptana RadRails, An IDE for Rails Development

Aptana RadRails: An IDE for Rails Development by Javier Ramírez discusses the latest Aptana RadRails IDE, a development environment for creating Ruby on Rails applications.

Fast Bytecodes for Funny Languages

Cliff Click discusses how to optimize generated bytecode for running on the JVM. Click analyzes and reports on several JVM languages and shows several places where they could increase performance.

Scott Ambler On Agile’s Present and Future

Scott Ambler, Practice Lead for Agile Development at IBM, speaks on the current status of the Agile community and practices having a look at the perspective of the Agile’s future.

Manager's Introduction to Test-Driven Development

Dave Nicolette and Karl Scotland try to introduce non-technical managers to one of the most popular Agile development techniques: Test-Driven Development (TDD).

Structured Event Streaming with Smooks

Smooks is best known for its transformation capabilities, but in this article Tom Fennelly describes how you can also use it for structured event streaming.

How to Work With Business Leaders to Manage Architectural Change

Successful architectures evolve over time to meet changing business requirements. Luke Hohmann presents how to collaborate with key members of your business to manage architectural changes.

Colors and the UI

In this article, Dr. Tobias Komischke explains how colors used in a GUI can influence our interaction with a computer and offers advice on using the appropriate colors for the interface.