This chapter and subsequent chapters feature Java 11. The Standard Edition (SE) of the Java platform can be downloaded from Oracle's official download site at the link (http://www.oracle.com/technetwork/java/javase/downloads/index.html).

An Integrated Development Environment (IDE) software package is sufficient. IntelliJ IDEA, from JetBrains, was used for all coding associated with this chapter and subsequent chapters. The Community version of IntelliJ IDEA can be downloaded from the website (https://www.jetbrains.com/idea/features/).

This chapter's source code is available at GitHub at the URL (https://github.com/PacktPublishing/Mastering-Java-11-Second-Edition).

The JVM uses heap space for classes and objects. The JVM allocates memory on the heap whenever we create an object. This helps facilitate Java's garbage collection, which releases memory previously used to hold objects that no longer have a memory reference. Java stack memory is a bit different and is usually much smaller than heap memory.

The JVM does a good job of managing data areas that are shared by multiple threads. It associates a monitor with every object and class; these monitors have locks that are controlled by a single thread at any one time. These locks, controlled by the JVM, are, in essence, giving the controlling thread the object's monitor. So, what contends locking? When a thread is in a queue for a currently locked object, it is said to be in contention for that lock. The following diagram shows a high-level view of this...

Java's segmented code cache upgrade was completed and results in faster, more efficient execution time. At the core of this change was the segmentation of the code cache into three distinct segments—non-method, profiled, and non-profiled code.

Each of the aforementioned code cache segments will hold a specific type of compiled code. As you can see in the following diagram, the code heap areas are segmented by type of compiled code:

The code heap containing non-method code is used for JVM internal code and consists of a 3 MB fixed memory block. The rest of the code cache memory is equally allocated...

All Java developers will be familiar with the javac tool for compiling source code to bytecode, which is used by the JVM to run Java programs. Smart Java compilation, also referred to as Smart Javac and sjavac, adds a smart wrapper around the javac process. Perhaps the core improvement added by sjavac is that only the necessary code is recompiled. Necessary code, in this context, is code that has changed since the last compile cycle.

This enhancement might not get developers excited if they only work on small projects. Consider, however, the tremendous gains in efficiency when you continuously have to recompile your code for medium and large projects. The time developers stand to save is reason enough to embrace JEP 199.

How will this change the manner in which you compile your code? It probably won't, at least not yet. Javac will remain the default...

Lint and doclint are sources that report warnings to javac. Let's take a look at each one:

• Lint analyzes bytecode and source code for javac. The goal of lint is to identify security vulnerabilities in the code being analyzed. Lint can also provide insights into scalability and thread locking concerns. There is more to lint and the overall purpose is to save developers time.

• Doclint is similar to lint and is specific to javadoc. Both lint and doclint report errors and warnings during the compile process. Resolution of these warnings was the focus of JEP 212. When using core libraries, there should not be any warnings. This mindset led to JEP 212, which has been resolved and implemented in Java 9.

Javac's type-checking has been streamlined. Let's first review how type-checking works in Java 8; then we will explore the changes in the modern Java platform.

In Java 8, type-checking of poly expressions is handled by a speculative attribution tool.

Using the speculative attribution approach to type-checking is accurate, but lacks efficiency. These checks include argument position and are exponentially slower when testing in the midst of recursion, polymorphism, nested loops, and Lambda expressions. So, the update was intended to change the type-checking schema to create faster results. The results themselves were not inaccurate with speculative attribution; they were just not generated rapidly.

The...

Java annotations refer to a special kind of metadata that resides inside your Java source code files. They are not stripped by javac so that they can remain available to the JVM at runtime.

Annotations look similar to JavaDocs references because they start with the @ symbol. There are three types of annotations. Let's examine each of these as follows:

• The most basic form of annotation is a marker annotation. These are standalone annotations, with the only component being the name of the animation. Here is an example:

@thisIsAMarkerAnnotation
public double computeSometing(double x, double y) {
     // do something and return a double
}

• The second type of annotation is one that contains a single value, or piece of data. As you can see in the following code, the annotation, which starts with the @ symbol, is followed by parentheses containing data...

Prior to Java 9, the release numbers did not follow industry standard versioning—semantic versioning. For example, the last four JDK 8 releases were as follows:

• Java SE 8 Update 144
• Java SE 8 Update 151
• Java SE 8 Update 152
• Java SE 8 Update 161
• Java SE 8 Update 162

Semantic versioning uses a major, minor, patch (0.0.0) schema as follows:

• Major equates to new API changes that are not backward compatible
• Minor is when functionality is added that is backward compatible
• Patch refers to bug fixes or minor changes that are backward compatible

Oracle has embraced semantic versioning starting with Java 9 and beyond. For Java, a major-minor-security schema will be used for the first three elements of Java version numbers:

• Major: A major release consisting of a significant new set of features
• Minor: Revisions and bug fixes that are backward compatible...

Java is arguably the most commonly used programming language and resides on an increasingly diverse number of platforms. This exacerbates the problem of running targeted compiler tests in an efficient manner. The new Java platform includes a tool that automates the runtime compiler tests.

This new tool starts by generating a random set of Java source code and/or bytecode. The generated code will have three key characteristics:

• It will be syntactically correct
• It will be semantically correct
• It will use a random seed that permits reusing the same randomly generated code

The source code that is randomly generated will be saved in the following directory:

hotspot/test/testlibrary/jit-tester

These test cases will be stored for later reuse. They can be run from the j-treg directory or from the tool's makefile. One of the benefits...

The lack of, or insufficient, capability to create tests for class-file attributes was the impetus behind the effort to ensure javac creates a class-file's attributes completely and correctly. This suggests that even if some attributes are not used by the class-file, all class-files should be generated with a complete set of attributes. There also needs to be a way of testing that the class-files were created correctly, in regards to the file's attributes.

Prior to Java 9, there was no method of testing a class-file's attributes. Running a class and testing the code for anticipated or expected results were the most commonly used method of testing javac generated class-files. This technique falls short of testing to validate the file's attributes.

There are three categories of class-file attributes—attributes...

In Java 5 through Java 8, the method in which strings were stored and accessed to and from CDS archives was inefficient, excessively time-consuming, and wasted memory. The following diagram illustrates the method by which Java stored interned strings in a CDS archive prior to Java 9:

The inefficiency stemmed from the storage schema. This was especially evident when the CDS tool dumped the classes into the shared archive file. The constant pools containing CONSTANT_String items have a UTF-8 string representation.

With the use of UTF-8 prior to Java 9, the strings had to be converted to string...

JavaFX is a set of packages that permit the design and development of media-rich graphical user interfaces. JavaFX applications provide developers with a great API for creating a consistent interface for applications. Cascading Style Sheets (CSS) can be used to customize the interfaces. One of the great things about JavaFX is that the tasks of programming and interface design can easily be separated.

JavaFX contains a wonderful visual scripting tool called Scene Builder, which allows you to create graphical user interfaces by using drag-and-drop and property settings. Scene Builder generates the necessary FXML files that are used...

The string data type is an important part of nearly every Java app. Prior to Java 9, string data was stored as an array of chars. This required 16 bits for each char. It was determined that the majority of string objects could be stored with only 8 bits, or 1 byte of storage. This is due to the fact that most strings consist of Latin-1 characters.

Starting with Java 9, strings are now internally represented using a byte array, along with a flag field for encoding references.

Xerces is a library used for parsing XML in Java. It was updated to 2.11.0 in late 2010, and JAXP was updated to incorporate changes in Xerces 2.11.0.

Prior to Java 9, the JDK's latest update regarding XML processing was based on Xerces 2.7.1. There were some additional changes to JDK 7 based on Xerces, 2.10.0. Java now has a further refinement of the JAXP based on Xerces 2.11.0.

Xerces 2.11.0 supports the following standards:

• XML 1.0, Fourth Edition
• Namespaces in XML 1.0, Second Edition
• XML 1.1, Second Edition
• Namespaces in XML 1.1, Second Edition
• XML Inclusions 1.0, Second Edition
• Document Object Model (DOM):
• Level 3:
  • Core
  • Load and save
• Level 2:
  • Core
  • Events

• Traversal and Range
• Element Traversal, First Edition
• Simple API for XML 2.0.2
• Java APIs for XML Processing (JAXP...

JavaFX is used for creating desktop and web applications. JavaFX was created to replace Swing as Java's standard GUI library. The Media class, javafx.scene.media.Media, is used to instantiate an object representing a media resource. JavaFX/Media refers to the following class:

public final class Media extends java.lang.Object

This class provides referential data to a media resource. The javafx.scene.media package provides developers with the ability to incorporate media into their JavaFX applications. JavaFX/Media utilizes a GStreamer pipeline.

The update to the modern Java platform ensures JavaFX/Media was updated to include the...

Prior to Java 9, the layout engine was used to handle font complexities, specifically fonts that have rendering behaviors beyond what the common Latin fonts have. Java used the uniform client interface, also referred to as ICU, as the de facto text rendering tool. The ICU layout engine has been depreciated and, in Java 9, has been replaced with the HarfBuzz font layout engine.

HarfBuzz is an OpenType text rendering engine. This type of layout engine has the characteristic of providing script-aware code to help ensure text is laid out as desired.

The impetus for the change from the ICU layout engine to the HarfBuzz font layout engine was IBM's decision to cease supporting the ICU layout engine. Therefore, the JDK was updated to contain the HarfBuzz font layout engine.

A concerted effort was made to ensure the crispness of on-screen components relative to the pixel density of the display. The following terms are relevant to this effort and are provided along with the accompanying listed descriptive information:

• DPI-aware application: An application that is able to detect and scale images for the display's specific pixel density.
• DPI-unaware application: An application that makes no attempt to detect and scale images for the display's specific pixel density.
• HiDPI graphics: High dots-per-inch graphics.
• Retina display: This term was created by Apple to refer to displays with a pixel density of at least 300 pixels per inch. Displaying graphics, both images, and graphical user interface components, to the user is typically of paramount performance. Displaying this imagery in high quality can be somewhat...

The Pisces graphics rasterizer has been replaced with the Marlin graphics renderer in the Java 2D API. This API is used to draw 2D graphics and animations.

The goal was to replace Pisces with a rasterizer/renderer that was much more efficient and without any quality loss. This goal was realized in Java 9. An intended collateral benefit was to include a developer-accessible API. Previously, the means of interfacing with the AWT and Java 2D was internal.

Unicode 8.0.0 was released on June 17, 2015. Java's relevant APIs were updated to support Unicode 8.0.0.

Unicode 8.0.0 added nearly 8,000 characters. Here are the highlights of the release:

• Ahom script for the Tai Ahom language (India)
• Arwi, Tamil language (Arabic)
• Cherokee symbols
• CJK unified ideographs
• Emoji symbols along with flesh-tone symbol modifiers
• Georgian Lari currency symbol
• lk language (Uganda)
• Kulango language (Cote d'Ivoire)

In order to fully comply with the new Unicode standard, several...

Problems stemming from stack overflows during the execution of critical sections have been mitigated. This mitigation takes the form of reserving additional thread stack space.

The JVM throws StackOverflowError when it is asked to perform data computation in a thread that has insufficient stack space and does not have permission to allocate additional space. This is an asynchronous exception. The JVM can also throw the StackOverflowError exception synchronously when a method is invoked.

When a method is invoked, an internal process is used to report the stack overflow. While the current schema works sufficiently for reporting the error, there is no room for...

Java interoperability has been enhanced. The necessary JDK changes were made to permit runtime linkers from multiple languages to coexist in a single JVM instance. This change applies to high-level operations, as you would expect. An example of a relevant high-level operation is the reading or writing of a property with elements such as accessors and mutators.

The high-level operations apply to objects of unknown types. They can be invoked with INVOKEDYNAMIC instructions. Here is an example of calling an object's property when the object's type is unknown at compile time:

INVOKEDYNAMIC "dyn:getProp:age"

Nashorn is a lightweight, high-performance...

One of the long-favored features of the Java platform is the behind-the-scenes garbage collection. An improvement goal was to create additional WhiteBox tests for humongous objects as a feature of the G1 garbage collector.

The G1 garbage collector worked extremely well, but there was room for some improved efficiency. The way the G1 garbage collector worked was based on first dividing the heap into regions of equal size, illustrated as follows:

The problem with the G1 garbage collector was how humongous objects were handled.

The problem with humongous objects was that if they...

Additional functionality has been added in Java to automatically collect information to support troubleshooting test failures as well as timeouts. Collecting readily available diagnostic information during tests stands to provide developers and engineers with greater fidelity in their logs and other output.

There are two basic types of information in the context of testing:

• Environmental
• Process

Each type of information is described in the following section.

When running tests, the testing environment information can be important for troubleshooting efforts. This information includes the following:

• CPU loads
• Disk space
• I/O loads
• Memory space
• Open files
• Open...

Prior to Java 9, string concatenation was translated by javac into StringBuilder : : append chains. This was a suboptimal translation methodology, often requiring StringBuilder presizing.

The enhancement changed the string concatenation bytecode sequence, generated by javac, so that it uses INVOKEDYNAMIC calls. The purpose of the enhancement was to increase optimization and to support future optimizations without the need to reformat the javac's bytecode.

The use of INVOKEDYAMIC calls to java.lang.invoke.StringConcatFactory allows us to use a methodology similar to Lambda expressions, instead of using StringBuilder's stepwise process. This results in more efficient processing of string concatenation.

HotSpot is the name of the JVM. This Java enhancement was intended to support the development of C++ unit tests for the JVM. Here is a partial, non-prioritized, list of goals for this enhancement:

• Command line testing
• Creating appropriate documentation
• Debugging compile targets
• Framework elasticity
• IDE support
• Individual and isolated unit testing
• Individualized test results
• Integrating with existing infrastructure
• Internal test support
• Positive and negative testing
• Short execution time testing
• Supporting all JDK 9 build platforms
• Test compile targets
• Test exclusion
• Test grouping
• Testing that requires the JVM to be initialized
• Tests co-located with source code
• Tests for platform-dependent code
• Writing and executing unit testing (for classes and methods)

This enhancement is evidence of the increasing extensibility.

GTK+, formally known as the GIMP toolbox, is a cross-platform tool used for creating graphical user interfaces. The tool consists of widgets accessible through its API. Java's enhancement ensures GTK 2 and GTK 3 are supported on Linux when developing Java applications with graphical components. The implementation supports Java apps that employ JavaFX, AWT, and Swing.

We can create Java graphical applications with JavaFX, AWT, and Swing. Here is a table summarizing those three approaches as they relate to GTK, prior to Java 9:

So, what changes were necessary to implement this enhancement? For JavaFX, three specific...

The Java platform used, prior to Java 9-11, was a build system riddled with duplicate code, redundancies, and other inefficiencies. The build system has been reworked for the modern Java platform based on the build-infra framework. In this context, infra is short for infrastructure. The overarching goal of this enhancement was to upgrade the build system to one that was simplified.

Specific goals included:

• Leveraging the existing build system
• Creating maintainable code
• Minimizing duplicate code
• Simplification
• Supporting future enhancements

The Java 9 platform consisted of eight distinct repositories, as depicted in the following diagram. In Java 10, all of these repositories were combined into a single repository:

Repository consolidation helps streamline development. Moreover, it increases the ease of maintaining and updating the Java platform.

In this chapter, we covered some impressive new features of the Java platform introduced with Java 9, 10, and 11. We focused on javac, JDK libraries, and various test suites. Memory management improvements, including heap space efficiencies, memory allocation, and improved garbage collection represent a powerful new set of Java platform enhancements. Changes regarding the compilation process that result in greater efficiencies were part of our chapter. We also covered important improvements, such as with the compilation process, type testing, annotations, and automated runtime compiler tests.

In the next chapter, we will look at several minor language enhancements introduced in Java 9, 10, and 11.

1. What is contented locking?
2. What is a code cache?
3. What is the command-line code used to define the code heap size for the profiled compiled methods?
4. What are lint and doclint in the context of warnings?
5. What is the directory used when auto-generating run-time compiler tests?
6. What flag is used with the -Xshare command-line option for CDS class determination?
7. What is the file name extension generated by Scene Builder?
8. Prior to Java 9, how was string data stored?
9. Starting with Java 9, how is string data stored?
10. What is OpenType?

The books listed here, also available as eBooks, will help you to dive deeper into Java 9 and JavaFX:

• Java 9 High Performance, available at https://www.packtpub.com/application-development/java-9-high-performance.
• JavaFX Essentials, available at https://www.packtpub.com/web-development/javafx-essentials.