A couple of weeks ago I wrote a summary of 7 new cool features in Java 7. Others have written great blog posts about them, so I was thinking it might be useful for me to focus on lesser known or “Hidden Java 7 Features”. In the next few weeks, I’ll try to explore and write a series of blog posts about them.

System and Process CPU Load Monitoring

Java 7 provides a new MBean that finally allows Java developers to access overall System and current process CPU load monitoring. This feature is not really that hidden as it’s listed in the what’s new page for JDK 7, but I haven’t really noticed a lot of talk about it and I certainly overlooked it initially.

The interface com.sun.management.OperatingSystemMXBean, has two new methods that easily get this information; getSystemCpuLoad() and getProcessCpuLoad(). Both methods return the load as a double value in the [0.0,1.0] interval, with 0.0 representing no load to 1.0 representing 100% CPU load for the whole system or the current JVM process respectively.

It’s pretty easy to get access to this MBean;

import com.sun.management.OperatingSystemMXBean;
...
OperatingSystemMXBean osBean = ManagementFactory.getPlatformMXBean(
                OperatingSystemMXBean.class);
// What % CPU load this current JVM is taking, from 0.0-1.0
System.out.println(osBean.getProcessCpuLoad());

// What % load the overall system is at, from 0.0-1.0
System.out.println(osBean.getSystemCpuLoad());

Wasn’t this already available?
Java 6 introduced a new method in java.lang.management.OperatingSystemMXBean called getSystemLoadAverage(), which could get the CPU average for the overall system (there wasn’t a mechanism for the JVM/current process load). However this doesn’t seem to work on Windows and would just return a -1 (tried this with Java 7 in Windows 7 and that is still the case).

Other ways of doing this prior to Java 7 would include Java APIs implemented via native libraries like SIGAR, which are good alternatives but obviously not part of the standard Java distribution, or may not support most platforms.

Now the bad news
If you notice in my code I use com.sun.management.OperatingSystemMXBean, not java.lang.management.OperatingSystemMXBean which means the methods getSystemCpuLoad() and getProcessCpuLoad() are not part of the official, supported public interface of the Java Platform. Oracle actually discourages the use of these packages, since they could be removed in future releases or may not be available in all JVM implementations.

I’m not 100% sure why these methods were only added to the com.sun version of OperatingSystemMXBean. Initially I thought it was because Oracle didn’t want to add a method to a public interface (which would break any code implementing that interface), however Java 6 added getSystemLoadAverage(). If anybody has any insight on this, please let me know.

There are ways to use these new methods without having a hard dependency to these com.sun classes (for example via reflection, or using JMX conventions), I may cover these in a future blog post or update to this one.

Demo, JCPUMon
Finally, I wanted to do a simple UI that would use this feature to have a little widget to monitor system CPU and current process load graphically. I call it “JCPMon”, it can be launched as a standalone Java application, run inside an application you want to monitor or just used as a Swing component in a Java UI.

The green part of the graph represents the overall system CPU load, while the yellow part represents the current process load, in this case CPU load imposed by the GUI (I did a lot of resizing to get a few yellow bars for this image ). If you want to monitor a Java application you already have, you can easily do so by calling;

// This method won't block, so you can call it at the start of your program
com.sellmic.apps.monitoring.jcpumon.Main(null);

// And then continue doing anything else ...

Of course an improvement would be to have the ability to connect to an external process via JMX (remote or local).

You can launch this app via webstart, .You’ll need Java 7 to be installed.

This simple GUI uses this new Java 7 capability and also has some extras to configure the look of the UI (squares or circles, size, how often to update, always on top, full screen). If anybody is interested in the code for this let me know and I can setup a page to host it.

UPDATE: JNLP URL was wrong, if you tried webstart before and it failed please try again. Sorry about that!

The evolution of the Java language and VM continues! Mark Reinhold (Chief Architect of the Java Platform Group) announced yesterday that the first release candidate for Java 7 is available for download, he confirms that the final released date is planned for July 28.

For a good overview of the new features and what’s coming next in Java 8, I recommend this video on the Oracle Media Network, which features Adam Messinger, Mark Reinhold, John Rose and Joe Darcy. I think Mark sums up Java 7 very well when describing it as an evolutionary release, with good number “smaller” changes that make for a great update to the language and platform.

I had a chance to play a bit with the release candidate (made easier by the Netbeans 7  JDK 7 support!), and decided to list 7 features (full list is here) I’m particularly excited about. Here they are;

1. Strings in switch Statements (doc)

Did you know previous to Java 7 you could only do a switch on char, byte, short, int, Character, Byte, Short, Integer, or an enum type (spec)? Java 7 adds Strings making the switch instruction much friendlier to String inputs. The alternative before was to do with with if/else if/else statements paired with a bunch of String.equals() calls. The result is much cleaner and compact code.

    public void testStringSwitch(String direction) {
        switch (direction) {
             case "up":
                 y--;
             break;

             case "down":
                 y++;
             break;

             case "left":
                 x--;
             break;

             case "right":
                 x++;
             break;

            default:
                System.out.println("Invalid direction!");
            break;
        }
    }

2. Type Inference for Generic Instance Creation (doc)

Previously when using generics you had to specify the type twice, in the declaration and the constructor;

List<String> strings = new ArrayList<String>();

In Java 7, you just use the diamond operator without the type;

List<String> strings = new ArrayList<>();

If the compiler can infer the type arguments from the context, it does all the work for you. Note that you have always been able do a “new ArrayList()” without the type, but this results in an unchecked conversion warning.

Type inference becomes even more useful for more complex cases;

// Pre-Java 7
// Map<String,Map<String,int>>m=new HashMap<String, Map<String,int>>();

// Java 7
Map<String, Map<String, int>> m = new HashMap<>();

3. Multiple Exception Handling Syntax (doc)

Tired of repetitive error handling code in “exception happy” APIs like java.io and java.lang.reflect?

try {
    Class a = Class.forName("wrongClassName");
    Object instance = a.newInstance();
} catch (ClassNotFoundException ex) {
    System.out.println("Failed to create instance");
} catch (IllegalAccessException ex) {
    System.out.println("Failed to create instance");
} catch (InstantiationException ex) {
   System.out.println("Failed to create instance");
}

When the exception handling is basically the same, the improved catch operator now supports multiple exceptions in a single statement separated by “|”.

try {
    Class a = Class.forName("wrongClassName");
    Object instance = a.newInstance();
} catch (ClassNotFoundException | IllegalAccessException |
   InstantiationException ex) {
   System.out.println("Failed to create instance");
}

Sometimes developers use a “catch (Exception ex) to achieve a similar result, but that’s a dangerous idea because it makes code catch exceptions it can’t handle and instead should bubble up (IllegalArgumentException, OutOfMemoryError, etc.).

4. The try-with-resources Statement (doc)

The new try statement allows opening up a “resource” in a try block and automatically closing the resource when the block is done.

For example, in this piece of code we open a file and print line by line to stdout, but pay close attention to the finally block;

        try {
            in = new BufferedReader(new FileReader("test.txt"));

            String line = null;
            while ((line = in.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException ex) {
            ex.printStackTrace();
        } finally {
            try {
                if (in != null) in.close();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }

When using a resource that has to be closed, a finally block is needed to make sure the clean up code is executed even if there are exceptions thrown back (in this example we catch IOException but if we didn’t, finally would still be executed). The new try-with-resources statement allows us to automatically close these resources in a more compact set of code;

       try (BufferedReader in=new BufferedReader(new FileReader("test.txt")))
       {
            String line = null;
            while ((line = in.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException ex) {
            ex.printStackTrace();
        }

So “in” will be closed automatically at the end of the try block because it implements an interface called java.lang.AutoCloseable. An additional benefit is we don’t have to call the awkward IOException on close(), and what this statement does is “suppress” the exception for us (although there is a mechanism to get that exception if needed, Throwable.getSuppressed()).

5. Improved File IO API (docs 1, 2)

There are quite a bit of changes in the java.nio package. Many are geared towards performance improvements, but long awaited enhancements over java.io (specially java.io.File) have finally materialized in a new package called java.nio.file.

For example, to read a small file and print all the lines (see example above);

       List<String> lines =  Files.readAllLines(
       FileSystems.getDefault().getPath("test.txt"), StandardCharsets.UTF_8);

       for (String line : lines) System.out.println(line);

java.nio.file.Path is an interface that pretty much serves as a replacement for java.io.File, we need a java.nio.file.FileSystem to get paths, which you can get by using the java.nio.file.FileSystems factory (getDefault() gives you the default file system).

java.nio.file.Files then provides static methods for file related operations. In this example we can read a whole file much more easily by using readAllLines(). This class also has methods to create symbolic links, which was impossible to do pre-Java 7. Another feature long overdue is the ability to set file permissions for POSIX compliant file systems via the Files.setPosixFilePermissions method. These are all long over due file related operations, impossible without JNI methods or System.exec() hacks.

I didn’t have time to play with it but this package also contains a very interesting capability via the WatchService API which allows notification of file changes. You can for example, register directories you want to watch and get notified when a file is added, removed or updated. Before, this required manually polling the directories, which is not fun code to write.

For more on monitoring changes read this tutorial from Oracle.

6. Support for Non-Java Languages: invokedynamic (doc)

The first new instruction since Java 1.0 was released and introduced in this version is called invokedynamic. Most developers will never interact or be aware of this new bytecode. The exciting part of this feature is that it improves support for compiling programs that use dynamic typing. Java is statically typed (which means you know the type of a variable at compile time) and dynamically typed languages (like Ruby, bash scripts, etc.) need this instruction to support these type of variables.

The JVM already supports many types of non-Java languages, but this instruction makes the JVM more language independent, which is good news for people who would like to implement components in different languages and/or want to inter-operate between those languages and standard Java programs.

7. JLayerPane (doc)

Finally, since I’m a UI guy, I want to mention JLayerPane. This component is similar to the one provided in the JXLayer project. I’ve used JXLayer many times in the past in order to add effects on top of Swing components. Similarly, JLayerPane allows you to decorate a Swing component by drawing on top of it and respond to events without modifying the original component.

This example from the JLayerPane tutorial shows a component using this functionality, providing a “spotlight” effect on a panel.

You could also blur the entire window, draw animations on top of components, or create transition effects.

And that’s just a subset of the features, Java 7 is a long overdue update to the platform and language which offers a nice set of new functionality. The hope is the time from Java 7 to 8 is a lot shorter than from 6 to 7!

Noticed a good post on this bug here via the Java Posse Google Group, if you parse the double “2.2250738585072012e-308″ it will hang a Thread, both at runtime (via parseDouble) or at compile time (just by defining referencing that number as a literal).

Examples (from the post at exploringbinary.com);

class runhang {
public static void main(String[] args) {
  System.out.println("Test:");
  double d = Double.parseDouble("2.2250738585072012e-308");
  System.out.println("Value: " + d);
 }
}

And then at compile time;

class compilehang {
public static void main(String[] args) {
  double d = 2.2250738585072012e-308;
  System.out.println("Value: " + d);
 }
}

See that blog post for a detailed analysis, it has links to the offending file in question (FloatingDecimal.java) and a pretty long comment list that is worth reading. Everybody is still trying to access what this impacts, and it seems to impact JVM based languages of course, and all platforms. I did notice on the Java Posse Group people saying that Android and Harmony are not affected (since they’re different implementations of course).

Impact of the bug? The most obvious one I can see is you can hang a thread on any JVM based software that accepts an input string that will be eventually parsed as a double. So for example a servlet on tomcat, you can eventually hang all HTTP threads and exhaust it’s thread pool to the point were it won’t be able to handle any more incoming request unless you restart the server. Ouch!

The bug will hang a thread, not the whole JVM (I wanted to clarify this because some people are saying it hangs the JVM, but it’s really the thread that is processing the call).

class hangthread {

    public static void main(String[] args) {

    Thread t1 = new Thread() {
        @Override
        public void run() {hangme();}};

    Thread t2 = new Thread() {
        @Override
        public void run() {hangme();}};

    Thread t3 = new Thread() {
        @Override
        public void run() {amialive();}};

        t3.start();
        t2.start();
        t1.start();
    }

    public static void amialive()
    {
        while (true){ System.out.println("I'm alive ...");
        try {Thread.sleep(1000);} catch (Exception e){}
        }
    }

    public static void hangme()
    {
        System.out.println("Test:" + Thread.currentThread().getName());
        double d = Double.parseDouble("2.2250738585072012e-308");
        System.out.println("Value: " + d);
    }
}

Seems this bug was originally reported to Sun on 04-MAR-2001(infinite loop while parsing double literal) !!!

A photo I took with James Gosling, during happier times (for Sun)

Uh oh … “Why I Quit Oracle”

eWEEK got quite the scoop interviewing Java creator James Gosling, where he finally spills the beans on why he quit Oracle earlier this year.

If you are a tech geek, or more likely a Java geek, you probably know who Gosling is. I first saw him presenting at my first JavaOne, and in JavaOne 2006 was fortunate enough to talk to him about how we were using Java for one of our projects and take a picture with him.

It’s hard to image a JavaOne without Gosling’s on stage and infectious enthusiasm. His tradition of catapulting T-shirts into the audience will be missed (maybe somebody at Oracle will give it a try? Let me know).

In the interview he mentions several things that contributed to his discontent; his salary, a modified job title, and perhaps more importantly a feeling that he had lost quite a bit of control and influence over the important decisions dealing with Java.

Gosling is a bit uncharacteristically harsh when he describers his previous boss,”He’s [Ellison] the kind of person that just gives me the creeps,”.

Ouch.

I have mixed feeling about this article. At first glance, and considering the timing (week of Oracle’s first JavaOne), it sounds like sour grapes. That was my first reaction. To be fair to Oracle, I don’t think it’s horribly unreasonable that if they acquired a company that wasn’t able to sutain itself, a lot of things were going to change, and they all include a lot of what James mentions (who makes decisions, job titles, how you are compensated).

A good example is this:

However, at Sun, any executive that was a vice president or above was given what amounted to a bump or bonus based on the performance of the company. “In a mediocre year you did OK, but in a good year you did great” in terms of this compensation, he said.

Perhaps this was part of the problem? Maybe Sun executives shouldn’t have been getting bonuses at all in a “mediocre year”. I’m not sure Oracle is being entirely unreasonable here.

On the other hand, based on Gosling’s description, it sounds like things could have been handled much better. He mentions that he felt he and his peers felt that their ability to decide anything was gone, and it’s completely understandable that this would be extremely frustrating. Specially when he’s the creator of the language, and is a well known and respected “tech celebrity” (do people in the real world know there’s such a thing?).

At the end of the day, Gosling has every right to complain, just like Oracle has every right to make internal decisions about how to run their business.

I hope James Gosling can still find ways to contribute to the project he gave birth to, just like people like Gafter and Bloch continue to be involved even though they work at different companies now (I mean Gafter is at Microsoft of all places!!!).

You can follow what James Gosling is up to at his blog.

JavaFX Script is officially dead.

Oracle has decided to continue investing in JavaFX as the UI platform for Java client applications, but at the same time they’ve realized that the JavaFX Script language was probably a limiting factor in the general adoption of their RIA technology.

History

On November 8, 2006, Sun engineer Chris Oliver published an entry in his blog introducing a project he had been working on called “F3″. His blog entry explained the general concepts behind the project;

My name is Chris Oliver. I came to Sun through their acquisition of Seebeyond in September 2005. I’d like to present something about my current work – it’s not public yet but it should be open-sourced on java.net shortly.

My project is called F3 which stands for “Form follows function”, and its purpose was to explore making GUI programming easier in general.

F3 is actually a declarative Java scripting language with static typing for good IDE support and compile-time error reporting (unlike JavaScript…), type-inference, declarative syntax, and automatic data-binding with full support for 2d graphics and standard Swing components as well as declarative animation. You can also import java classes, create new Java objects, call their methods, and implement Java interfaces.

Chris’ first blog post on F3 introduced code snippets showing off the main features of the language, and a follow up post had a set of very impressive demos meant to show off the language and how it could compete with other RIA technologies like Flash.

At JavaOne 2007 F3 was rebranded as JavaFX Script, and we were shown some cool demos, like this JavaFX PDF Reader which unfortunately was never released.

JavaFX 1.0 was released on December, 2008.

At JavaOne 2009, Sun showed off a much needed JavaFX designer tool. The demo showed how the tool would allow for visual design of JavaFX applications on different “screens” (desktop, mobile, TV, etc.). This tool hasn’t been released to the public, instead there’s a more developer oriented Netbeans plugin with Matisse like UI design capabilities that was released a while ago.

But it’s not Java

The complaint I would often hear from developers when talking about JavaFX is that it was not Java. Unlike Java, F3 was designed from the beginning with UIs in mind. Chris Oliver wanted the flexibility of a declarative language, and decided that XML was not the best fit for this, thus the need for the F3 language.

The problem was that the new language was very different from Java. I remember doing a JavaFX Script presentation for a JUG in Panama, and even after having written a few programs in it, the context switch between it and Java was quite big for me.

At the last JavaOne I attended, I could overhear a lot of people rejecting the idea of learning yet another new language just to do a Java based UI. Not only a new language, but one that was so different from what they were used to. People often forget that one of the reasons Java dominates the development landscape today is because it was so similar to it’s predecessors; C and C++. While the benefits of a new UI focused language are many (the binding features alone in JavaFX Script are a good example), one thing that I’ve noticed is that modern UIs are being done in less exotic ways; just take a look at the UI framework in Android which is Java language based and on iPhone which uses Objective C.

JavaFX technology in Java, and other languages

Oracle has published the proposed roadmap for JavaFX 2.0. The key standout feature listed there is “Port JavaFX Script APIs to Java”, which will make JavaFX not only easily available to Java developers but to those who use other dynamic languages like Scale, JRuby, Groovy, Javascript, etc. The roadmap also mentions support for lambda expressions (closures), which I can already see being very useful for UI programming.

There are other notable features listed there, like additional UI controls, web views and integration with HTML5, HD playback, etc. The roadmap mentions the binding API, I’m curious to see how it would be integrated in the core Java language.

I think Oracle has made the right move here, the JavaFX stack is already pretty advanced and shows a lot of promise. It should be used more, but was being hindered by the lack of adoption of JavaFX Script. Porting these APIs to Java, and supporting other dynamic languages should allow a lot more developers to leverage the power of JavaFX.

Sorry for the long post, but I wanted to include a bit of history at the beginning about F3. I wonder how Chris Oliver and the other engineers that worked so hard on the core JavaFX Script language feel about this development. Hopefully they feel pretty proud about their work, because even though the language is being dropped, it seems the core of JavaFX is pretty strong. Adoption should grow now that there is no “new language” excuse.

At least that’s what I’m hoping for.

Well, unfortunately for me I couldn’t make it to JavaOne this year. However I am happy Oracle is keeping JavaOne alive, and that my prediction from last year proved to be true (Is this the last JavaOne ever? – answer: no).

If you are not in San Francisco this week or have JavaOne passes, you can still attend virtually. Here are a few resources to keep you in touch;

• The official JavaOne 2010 Site
• Ustream live keynote video streams or here with schedule
• Twitter #javaone
• JavaOne on facebook

I’ve heard Oracle will keep Sun’s tradition of posting all the presentations at a later date, I will post the links as they become available.

I’ll also be trying to scan blogs for any interesting tidbits to be highlighted, so stay tuned.

Also, I didn’t make it this year but at least one of my silly drawings did. Thanks to Steve Chin for including my little Java/Duke Evolution picture into his “JavaFX Your Way: Building JavaFX Applications with Alternative Languages”.