5 Features in Java 9 that WILL Change How You Develop Software (and 2 That Won’t)

 ● 27th Jul 2017

7 min read

What are the most exciting features that are expected to be released in Java 9? (Originally Published 17-Jun-2015)

Don’t get distracted by the relative silence around Java 9! The JDK committers are hard at work preparing the next release, which is expected to be generally available in September 2017. Early access builds are already out in the wild and we’re counting down the days for general availability on the Java 9 Countdown website.
Today we have a pretty clear picture of the features we can expect in Java 9. If Java 8 could be described as the major release of lambdas, streams and API changes, then Java 9 is all about Jigsaw, jshell, and a collection of under the hood and API updates. In this post we’ve gathered some of the features we believe are the most exciting ones that are targeting Java 9 – Apart from the usual suspect, project Jigsaw, which took on the mission of breaking down the JRE and bringing modularity to Java’s core components.

[Update 7-Feb-2018: Java 9 is expected to revolutionize the way we think of and build large scale applications. Our Java 9 First Impressions webinar explores how.]


Join Webinar

Here some of the features which are an absolute must to know about in Java 9:

  1. Java + REPL = jshell
  2. Noteworthy API Updates: Concurrency and Stack Walking
  3. G1 will be the new default garbage collector
  4. HTTP 2.0 is the future
  5. The process API just got a huge boost


1. Java + REPL = jshell

Yes. Previously we had doubts that project Kulla would make it in time for Java 9 but now it’s official. The next release of Java will feature a new command line tool called jshell that will add native support and popularize a Java way to REPL (Read-Eval-Print-Loop). Meaning, say, if you’ll want to run a few lines of Java on their own you won’t have to wrap it all in a separate project or method. Oh and semicolons – you can forget about those:

There are some alternatives like REPL add-ons to popular IDEs and solutions like the Java REPL web console, but no official and right way to do this so far. jshell is already available in the early release and waiting for you to give it a test run.

2. Noteworthy API Updates: Concurrency and Stack Walking

As part of the update to this post, we wanted additional features we’ve covered extensively after the publishing of this post.
The first thing we want to mention here are the Java 9 concurrency updates with CompletableFuture and java.util.concurrent.Flow. Flow is the Java implementation of the Reactive Streams API, and we’re pretty excited that it’s coming to Java. Reactive Streams solve the pain of back-pressure. The build-up of data that happens when the incoming tasks rate is higher than the application’s ability to process them, which result in a buffer of unhandled data. As part of the concurrency updates, CompletableFuture will also get an update the will resolve complaints that came in after their introduction in Java 8. This will include support for delays and timeouts, better support for subclassing, and a few utility methods.
The second thing we wanted to mention here is the Stack Walking API. That’s right, Java 9 will change the way you traverse stack traces. This is basically an official Java way to process stack traces, rather than simply treating them as plain text. It also kind of sounds like a vague Star Wars reference. Which made us like it even more!

3. G1 will be the new default garbage collector

A common misconception we often hear is that Java has only one garbage collector when in fact it has 4. Prior to Java 9,  the default garbage collector was the Parallel / Throughput Collector, and now it will be replaced with G1 which was introduced in Java 7. For a bite sized overview about the differences between the collectors, you can check out this post right here.
Generally, G1 was designed to better support heaps larger than 4GB and has been known to cause less frequent GC pauses, but when a pause do comes, it tends to be longer. We’ve also discussed all things GC with Haim Yadid, head of performance at Next Insurance, to help you learn more about the different trade offs between the collectors.
[adrotate group=”11″]

4. HTTP 2.0 is the future

The official HTTP 2.0 RFC was approved not too long ago, building on top of Google’s SPDY algorithm. SPDY has already shown great speed improvements over HTTP 1.1 ranging between 11.81% to 47.7% and its implementation already exists in most modern browsers.
Java 9 will have full support for HTTP 2.0 and feature a new HTTP client for Java that will replace HttpURLConnection, and also implement HTTP 2.0 and websockets. Another cool thing about this new API is that it’s going to be introduced as the first incubator module in Java. An incubator module is basically an experimental feature that will either progress to be adopted in the next version of Java, Java 10 in this case, or it will be removed. A pretty unusual concept for Java that would encourage experimentation without breaking backwards compatibility.

5. The process API just got a huge boost

So far there has been a limited ability for controlling and managing operating system processes with Java. For example, in order to do something as simple as get your process PID in earlier versions of Java, you would need to either access native code or use some sort of a magical workaround. Moreover, it would require a different implementation for each platform to guarantee you’re getting the right result.
In Java 9, expect the code for retrieving Linux PIDs, that now looks like this:

To turn into something like this (that also supports all operating systems):

The update will extend Java’s ability to to interact with the operating system: New direct methods to handle PIDs, process names and states, and ability to enumerate JVMs and processes and more. This might not be too exciting for some but we at OverOps will probably make an extensive use of it so this is why we thought of highlighting it among the other features.

6. Solving Java Errors in Production

While not exclusive to Java 9, we thought this post would be a good opportunity to share some of the new progress we’ve been making. Solving errors in production has always been a messy practice, grepping for clues over huge log files, and trying to identify the state that caused each exception or logged error. But what if you could avoid logs altogether? Here’s how it’s done.
Many Java developers who were checking it out had quite a few questions about the tool, so we’ve also set up this form for 1 on 1 demos, check it out and schedule to schedule a personal walkthrough.

What you’ll not be seeing in Java 9?

Two interesting features that we assumed will make a part of the upcoming Java release – but now we know they will be skipped this time are.

1. A standardized lightweight JSON API

On a survey we conducted with 350 developers, the JSON API was just as hyped as Jigsaw but looks like it didn’t make the cut due to funding issues. Mark Reinhold, chief architect of the Java platform, on the JDK 9 mailing list:
“This JEP would be a useful addition to the platform but, in the grand scheme of things, it’s not as important as the other features that Oracle is funding, or considering funding, for JDK 9. We may reconsider this JEP for JDK 10 or a later release. ”

2. Money and Currency API

In other news, it also looks like the expected Money and Currency API is also lacking Oracle support. This is the answer we got from Anatole Tresch, the APIs spec lead:

3. As part of the update to this post, we thought it’s also worth mentioning Project Amber. A project that’s targeting future Java versions, beyond Java 9. Read more.

Did we miss anything? Let us know in the comments below.

Alex is the Director of Product Marketing at OverOps. As an engineer-turned-marketer, he is passionate about transforming complex topics into simple narratives and using his experience to help software engineering navigate their way through the crowded DevOps landscape.

Troubleshooting Apache Spark Applications with OverOps OverOps’ ability to detect precisely why something broke and to see variable state is invaluable in a distributed compute environment.
Troubleshooting Apache Spark Applications with OverOps

Next Article

The Fastest Way to Why.

Eliminate the detective work of searching logs for the Cause of critical issues. Resolve issues in minutes.
Learn More