The State of Java: Meeting the Multicore Challenge
"The multicore challenge" is the challenge to developers of software products to write code that effectively utilizes modern multi-core / multi-processor computers. Two years ago, I wondered if the multicore challenge was still relevant. In part, I was thinking about how applications were moving from the desktop into the cloud. So, if the apps people are running are running in a browser, does it matter if their desktop system (or pad or phone) is multicore?
Today many mobile phones can really be looked at as being computers. In an article about the contributions mobile phones are making in poor countries, the Economist noted that "Mobile phones are the world's most widely distributed computers." And many of the newer mobile phones are multicore.
So really, whether the target computer for your software is a traditional tower, a laptop, a pad, or a phone, the multicore challenge remains relevant today -- and its relevance will only increase in the coming years. Browsers, one would think, are going to have to evolve to utilize multiple cores and processors. The ones that do so will ultimately take away significant market share from the ones that don't. How they'll accomplish this is another question...
Java already has basic capabilities for utilizing multiple processors -- in the threads library, for example. But, clearly that's considered inadequate for meeting the needs of the future. Which is why we have JSR 335: Lambda Expressions for the Java(TM) Programming Language. The development of JSR 335 takes place in Project Lambda, a component of the OpenJDK project.
At JavaOne 2011, Alex Buckley presented a very well attended session titled "Project Lambda: To Multicore and Beyond" that outlined the vision and plan for bringing Lambda expressions into Java. This will happen in Java 8 -- so, we're still a ways away from having a formal release.
The key element, in my view, is that Lambda expressions (also called "closures") will be implemented largely via a rewrite of the underlying JDK libraries wherein they will "automatically" do the low-level work of divying up the task at hand and passing segments of it to the available processor cores. This will enormously reduce the effort for Java application developers to convert their existing programs such that they can utilize multiple processors/cores.
Writing multithreaded code is hard. I've been doing it for 18 years, starting out on 8-processor Sun machines where we took scientific C and Fortran code delivered by researchers and revised it to parcel out data segments to different threads. Tiny mistakes inevitably result in overwritten data, which produces non-repeatable erroneous results, crashes, hung threads, and other "fun" head-scratchers... Yeah, it's hard to write threadsafe code!
The approach taken by the Java 8 architects and developers is going to in essence hide all that complicated threading stuff from the higher level app developer, by implementing the multithreading and fork/join processing within the Java libraries themselves. This is an enormous effort in itself, but it's a much smaller effort than if every Java application development team had to multithread their apps, having to rewrite function after function to be threadsafe.
Of course, the efficiency of the apps on multicore computers will thus depend on how much of the processing actually occurs within the core Java libraries. It's not going to be a situation where, because of Project Lambda, all apps will suddenly utilize all available cores 100% of the time, and immediately speed up by nC times (where nC is the number of cores in the computer).
Still, Project Lambda is a major innovation, a key step into the future for Java.
If you find all this interesting, you may want to take a look at Mike Duigou's JavaOne 2011 presentation "Bulk Hauling: Parallel Data and Lambdas in Java 8." The PDF for that is available in the JavaOne Content Catalog.
- Kirk Pepperdine, Is setting -Xmx==-Xms still considered harmful?;
- David Herron, The DLJ project is dead - long live the OpenJDK;
- Brian O'Neill, Programmatically submitting jobs to a remote Hadoop cluster;
- Manfred Riem, Using HtmlUnit, Glassfish and Maven in a multi-project setup for integration testing;
- Bongjae Chang, Introduction to Grizzly-Thrift and sharing the benchmarking results; and
- Carol McDonald, Finding bugs that matter with Findbugs .
Our current java.net poll asks you to respond to The most important Java/JVM related happening in 2011 was. Voting will be open until Friday, December 23.
Here are the stories we've recently featured in our Java news section:
- Maurizio Cimadamore outlines the Lambda Integration Plan;
- Jasper Potts demonstrates Styling FX Buttons with CSS;
- Geertjan Wielenga celebrates an Industry Award for Microchip's NetBeans Platform Application;
- Michael Kopp presents How to manage the performance of 1000+ JVMs;
- Geertjan Wielenga shares NetBeans API Video Tip 1: Decoupling via Lookup.Provider;
- Adam Bien reports Java FX 2
Related Topics >>