E-Book
41,99 €

Mastering Java 9 E-Book

Dr. Edward Lavieri

0,0

41,99 €

Sammeln Sie Punkte in unserem Gutscheinprogramm und kaufen Sie E-Books und Hörbücher mit bis zu 100% Rabatt.

Mehr erfahren.

Herausgeber: Packt Publishing
Kategorie: Wissenschaft und neue Technologien
Sprache: Englisch

Beschreibung

Your road to becoming a Java Ninja begins here!

About This Book

This book will teach you to build highly scalable, fast, and secure applications
It covers major concepts introduced with the new version of Java 9, which includes modular programming, HTTP 2.0, API changes, and more
It will guide you with tools, techniques and best practices to enhance application development

Who This Book Is For

This book is for enterprise developers and existing Java developers. Basic knowledge of Java would help.

What You Will Learn

Write modular Java applications in terms of the newly introduced module system
Migrate existing Java applications to modular ones
Understand how to use the G1 garbage collector in order to leverage the performance of your applications
Leverage the possibilities provided the newly introduced Java shell
Test your application's effectiveness with the JVM harness
See how Java 9 provides support for the http 2.0 standard
Use the new process API
Discover additional enhancements and features provided by Java 9

In Detail

Java 9 and its new features add to the richness of the language, one of the languages most used by developers to build robust software applications. Java 9 comes with a special emphasis on modularity with its integration with Jigsaw. This would be your one-stop guide to mastering the language.

You'll be provided with an overview and explanation of the new features introduced in Java 9 and the importance of the new APIs and enhancements. Some of the new features of Java 9 are ground-breaking and if you are an experienced programmer, you will be able to make your enterprise application leaner by learning these new features. You'll be provided with practical guidance in applying the newly acquired knowledge in regards to Java 9 and further information on future developments of the Java platform. This book will improve your productivity, making your application faster. By learning the best practices in Java, you'll become the “go-to” person in your organization.

By the end of the book, you'll not only know the important concepts of Java 9, but you'll also have a nuanced understanding of the important aspects of programming with this great language.

Style and approach

Concepts and new terminology are explained in simple step-by-step manner. We cover a lot of real-world examples and case studies that will improve your Java productivity. This book covers new features on Java 9 and the much talked about Jigsaw integration.

Details

Sie lesen das E-Book in den Legimi-Apps auf:

Android

iOS

von Legimi
zertifizierten E-Readern

Seitenzahl: 406

Veröffentlichungsjahr: 2017

Bewertungen

0,0

Rezensionen(0 Rezensionen)

Leseprobe

Mastering Java 9

Write reactive, modular, concurrent, and secure code

Dr. Edward Lavieri

Peter Verhas

BIRMINGHAM - MUMBAI

Mastering Java 9

All rights reserved. No part of this book may be reproduced, stored in a retrieval system, or transmitted in any form or by any means, without the prior written permission of the publisher, except in the case of brief quotations embedded in critical articles or reviews.

Every effort has been made in the preparation of this book to ensure the accuracy of the information presented. However, the information contained in this book is sold without warranty, either express or implied. Neither the authors, nor Packt Publishing, and its dealers and distributors will be held liable for any damages caused or alleged to be caused directly or indirectly by this book.

Packt Publishing has endeavored to provide trademark information about all of the companies and products mentioned in this book by the appropriate use of capitals. However, Packt Publishing cannot guarantee the accuracy of this information.

First published: October 2017

Production reference: 1031017

Published by Packt Publishing Ltd.

Livery Place

35 Livery Street

Birmingham

B3 2PB, UK.

ISBN 978-1-78646-873-4

www.packtpub.com

Credits

Authors

Dr. Edward Lavieri

Peter Verhas

Copy Editor

Safis Editing

Reviewer

Mandar Jog

Project Coordinator

Prajakta Naik

Commissioning Editor

Kunal Parikh

Proofreader

Safis Editing

Acquisition Editor

Denim Pinto

Indexer

Francy Puthiry

ContentDevelopmentEditor

Lawrence Veigas

Graphics

Jason Monteiro

Technical Editor

Abhishek Sharma

Production Coordinator

Arvindkumar Gupta

About the Authors

Dr. Edward Lavieri is a veteran developer with a strong academic background. He earned a doctorate in computer science from Colorado Technical University, an MS in management information systems (Bowie State University), an MS in education (Capella University), and an MS in operations management (University of Arkansas).

He has been creating and teaching computer science courses since 2002. Edward retired from the U.S. Navy as a Command Master Chief after 25 years of service. As the founder and creative director of three19, a software design and development studio, Edward is constantly designing and developing software. He uses a variety of game engines and development tools. His passions include developing adaptive learning systems, educational games, and mobile apps.

Edward has authored Adaptive Learning for Educational Game Design (CreateSpace), Getting Started with Unity 5 (Packt), Learning AWS Lumberyard Game Development (Packt),LiveCode Mobile Development HOTSHOT (Packt), LiveCode Mobile Development Cookbook (Packt), and Software Consulting: A Revolutionary Approach (CreateSpace). He was the technical editor for Excel Formulas and Functions for Dummies (Wiley Publishing). He has also developed numerous college courses involving computer science, information systems, and game development.

Peter Verhas is a senior developer and software system architect with more than 30 years of software development experience. He currently works for EPAM as a senior developer, where he is involved in many customer projects and actively participates in the education activities of the company. Peter writes a technical blog and is committed to open source software development. He has been using Java since 2005 and is also an author at Java Code Geeks.

About the Reviewer

Mandar Jogis an expert IT trainer with over 15 years of training experience. He is an expert in technologies such as Java, J2EE, and Android. He also holds SCJP and SCWCD certifications. He is an occasional blogger where he makes the readers feel "I can" for the complex concepts in Java and J2EE. He is a regular speaker at many engineering colleges for technical seminars and workshops.

He was also the technical reviewer of the book, Modular Programming in Java 9 by Packt.

Thanks a lot Tejaswini, you have been my inspiration throughout this journey. I am equally grateful to my son, Ojas; his lovely smiles have always made me push myself further.

www.PacktPub.com

For support files and downloads related to your book, please visit www.PacktPub.com.

Did you know that Packt offers eBook versions of every book published, with PDF and ePub files available? You can upgrade to the eBook version at www.PacktPub.com and as a print book customer, you are entitled to a discount on the eBook copy. Get in touch with us at [email protected] for more details.

At www.PacktPub.com, you can also read a collection of free technical articles, sign up for a range of free newsletters and receive exclusive discounts and offers on Packt books and eBooks.

www.packtpub.com/mapt

Get the most in-demand software skills with Mapt. Mapt gives you full access to all Packt books and video courses, as well as industry-leading tools to help you plan your personal development and advance your career.

Why subscribe?

Fully searchable across every book published by Packt

Copy and paste, print, and bookmark content

On demand and accessible via a web browser

Customer Feedback

Thanks for purchasing this Packt book. At Packt, quality is at the heart of our editorial process. To help us improve, please leave us an honest review on this book's Amazon page at https://www.amazon.com/dp/1786468735.

If you'd like to join our team of regular reviewers, you can e-mail us at [email protected]. We award our regular reviewers with free eBooks and videos in exchange for their valuable feedback. Help us be relentless in improving our products!

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Downloading the example code

Errata

Piracy

Questions

The Java 9 Landscape

Java 9 at 20,000 feet

Breaking the monolith

Playing around with the Java Shell

Taking control of external processes

Boosting performance with G1

Measuring performance with JMH

Getting started with HTTP 2.0

Encompassing reactive programming

Expanding the wish list

Summary

Discovering Java 9

Improved Contended Locking [JEP 143]

Improvement goals

Segmented code cache [JEP 197]

Memory allocation

Smart Java compilation, phase two [JEP 199]

Resolving Lint and Doclint warnings [JEP 212]

Tiered attribution for javac [JEP 215]

Annotations pipeline 2.0 [JEP 217]

New version-string scheme [JEP 223]

Generating run-time compiler tests automatically [JEP 233]

Testing class-file attributes generated by Javac [JEP 235]

Storing interned strings in CDS archives [JEP 250]

The problem

The solution

Preparing JavaFX UI controls and CSS APIs for modularization [JEP 253]

JavaFX overview

Implications for Java 9

Compact strings [JEP 254]

Pre-Java 9 status

New with Java 9

Merging selected Xerces 2.11.0 updates into JAXP [JEP 255]

Updating JavaFX/Media to newer version of GStreamer [JEP 257]

HarfBuzz Font-Layout Engine [JEP 258]

HiDPI graphics on Windows and Linux [JEP 263]

Marlin graphics renderer [JEP 265]

Unicode 8.0.0 [JEP 267]

New in Unicode 8.0.0

Updated Classes in Java 9

Reserved stack areas for critical sections [JEP 270]

The pre-Java 9 situation

New in Java 9

Dynamic linking of language-defined object models [JEP 276]

Proof of concept

Additional tests for humongous objects in G1 [JEP 278]

Improving test-failure troubleshooting [JEP 279]

Environmental information

Java process information

Optimizing string concatenation [JEP 280]

HotSpot C++ unit-test framework [JEP 281]

Enabling GTK 3 on Linux [JEP 283]

New HotSpot build system [JEP 284]

Summary

Java 9 Language Enhancements

Working with variable handlers [JEP 193]

Working with the AtoMiC Toolkit

Using the sun.misc.Unsafe class

Eliding depreciation warnings on import statements [JEP 211]

Milling Project Coin [JEP 213]

Using the @SafeVarargs annotation

The try-with-resource statement

Using the diamond operator

Discontinuing use of the underscore

Making use of private interface methods

Processing import statements correctly [JEP 216]

Summary

Building Modular Applications with Java 9

A modular primer

Reviewing Java's platform module system [JEP-200]

Modularizing JDK source code [JEP-201]

Pre-Java 9 JDK source code organization

Development tools

Deployment

Internationalization

Monitoring

RMI

Security

Troubleshooting

Web services

JavaFX tools

Java runtime environment

Source code

Libraries

C header files

Database

JDK source code reorganized

Understanding modular run-time images [JEP-220]

Runtime format adoption

Runtime image restructure

Supporting common operations

De-privileging JDK classes

Preserving existing behaviors

Getting to know the module system [JEP-261]

Module paths

Access-control boundary violations

Runtime

Modular Java application packaging [JEP-275]

Advanced look at the Java Linker

Java Packager options

JLink - The Java Linker [JEP-282]

Encapsulating most internal APIs [JEP-260]

Summary

Migrating Applications to Java 9

Quick review of Project Jigsaw

Classpath

The monolithic nature of the JDK

How modules fit into the Java landscape

Base module

Reliable configuration

Strong encapsulation

Migration planning

Testing a simple Java application

Potential migration issues

The JRE

Access to internal APIs

Accessing internal JARs

JAR URL depreciation

Extension mechanism

The JDK's modularization

Advice from Oracle

Preparatory steps

Getting the JDK 9 early access build

Running your program before recompiling

Updating third-party libraries and tools

Compiling your application

Pre-Java 9 -source and -target options

Java 9 -source and -target options

Running jdeps on your code

Breaking encapsulation

The --add-opens option

The --add-exports option

The --permit-illegal-access option

Runtime image changes

Java version schema

JDK and JRE layout

What has been removed

Updated garbage collection

Deployment

JRE version selection

Serialized applets

JNLP update

Nested resources

FX XML extension

JNLP file syntax

Numeric version comparison

Useful tools

Java environment - jEnv

Maven

Obtaining the M2Eclipse IDE

Summary

Experimenting with the Java Shell

What is JShell?

Getting Started with JShell

Practical uses of JShell

Feedback modes

Creating a custom feedback mode

Listing your assets

Editing in the JShell

Modifying text

Basic navigation

Historical navigation

Advanced editing commands

Working with scripts

Start up scripts

Loading scripts

Saving scripts

Advanced scripting with JShell

Summary

Leveraging the New Default G1 Garbage Collector

Overview of garbage collection

Object life cycle

Object creation

Object mid-life

Object destruction

Garbage collection algorithms

Mark and sweep

Concurrent mark sweep (CMS) garbage collection

Serial garbage collection

Parallel garbage collection

G1 garbage collection

Garbage collection options

Java methods relevant to garbage collection

The System.gc() method

The finalize() method

Pre-Java 9 garbage collection

Visualizing garbage collection

Garbage collection upgrades in Java 8

Case study - Games written with Java

Collecting garbage with the new Java platform

Default garbage collection

Depreciated garbage collection combinations

Unified garbage collection logging

Unified JVM logging (JEP-158)

Preface

Java 9 and its new features add to the richness of the language--one of the most-used languages to build robust software applications. Java 9 comes with a special emphasis on modularity, implemented from Project Jigsaw. This book is your one-stop guide to mastering the changes made to the Java platform.The book gives an overview and explanation of the new features introduced in Java 9 and the importance of the new APIs and enhancements. Some of the new features of Java 9 are groundbreaking, and if you are an experienced programmer, you will be able to make your enterprise application leaner by implementing these new features. You will be provided with practical guidance in applying the newly acquired knowledge in regards to Java 9 and further information on future developments of the Java platform. This book will improve your productivity, making your applications faster. By learning the best practices in Java, you will become the go-to person in your organization for Java 9.By the end of this book, you will not only know the important concepts of Java 9 but you will also have a nuanced understanding of the important aspects of programming with this great language.

What this book covers

Chapter 1, The Java 9 Landscape, explores the most significant features introduced in Java 9, including Project Jigsaw, the Java Shell, G1 garbage collection, and reactive programming. This chapter provides introductions to these topics, priming them for deeper coverage in the subsequent chapters.

Chapter 2, Discovering Java 9, covers several changes to the Java platform to include heap space efficiencies, memory allocation, compilation process improvements, type testing, annotations, automated runtime compiler tests, and improved garbage collection.

Chapter 3, Java 9 Language Enhancements, focuses on the changes made to the Java language. These changes impact variable handlers, depreciation warnings, improvements on Project Coin changes implemented in Java 7, and import statement processing.

Chapter 4, Building Modular Applications with Java 9, examines the structure of a Java module as specified by Project Jigsaw and how Project Jigsaw was implemented as part of the Java platform. This chapter also reviews the key internal changes to the Java platform as they relate to the new modular system.

Chapter 5, Migrating Applications to Java 9, explores how to migrate Java 8 applications to the Java 9 platform. Both manual and semi-automated migration processes are covered.

Chapter 6, Experimenting with the Java Shell, covers JShell, the new command-line read-eval-print loop tool in Java 9. Coverage includes information regarding the tool, the read-eval-print loop concept, and the commands and command-line options for use with JShell.

Chapter 7, Leveraging the New Default G1 Garbage Collector, takes an in-depth look at garbage collection and how it is handled in Java 9.

Chapter 8, Microbenchmarking Applications with JMH, examines how to write performance tests using the Java Microbenchmark Harness (JMH), a Java harness library for writing benchmarks for the Java Virtual Machine (JVM). Maven is used along with JMH to help illustrate the power of microbenchmarking with the new Java 9 platform.

Chapter 9, Making Use of the ProcessHandle API, reviews new class APIs that enable the management of operating system processes.

Chapter 10, Fine-Grained Stack Tracing, covers the new API that permits an effective means of stack walking. The chapter includes detailed information on how to access stack trace information.

Chapter 11, New Tools and Tool Enhancements, covers 16 Java Enhancement Proposals (JEPs) that were incorporated into the Java 9 platform. These JEPs cover a wide range of tools and updates to APIs to make development with Java easier with greater optimization possibilities for our Java applications.

Chapter 12, Concurrency Enhancements, covers concurrency enhancements introduced with the Java 9 platform. The primary focus isthe support for reactive programming, a concurrency enhancement that is provided by the Flow class API. Additional concurrency enhancements introduced in Java 9 are also covered.

Chapter 13, Security Enhancements, covers several small changes made to the JDK that involve security. The security enhancements introduced with the Java 9 platform provide developers with a greater ability to write and maintain applications that are more secure than previously possible.

Chapter 14, Command-Line Flags, explores the command-line flag changes in Java 9. Concepts covered in this chapter include unified JVM logging, compiler control, diagnostic commands, heap-profiling agent, JHAT, command-line flag argument validation, and compiling for older platform versions.

Chapter 15, Best Practices in Java 9, focuses on working with utilities provided by the Java 9 platform to include UTF-8 property files, Unicode 7.0.0, Linux/AArch64 port, multiresolution images, and common locale data repository.

Chapter 16, Future Directions, provides an overview of the future developments of the Java platform, beyond Java 9. This includes a specific look at what is planned for Java 10 and what further changes we are likely to see in the future.

What you need for this book

To work with this text, you will need at least a basic knowledge of the Java programming language.

You will also need the following software components:

Java SE Development Kit 9 (JDK)

http://www.oracle.com/technetwork/java/javase/downloads/

An Integrated Development Environment (IDE) for coding. Here are suggestions:

Eclipse

https://www.eclipse.org

IntelliJ

https://www.jetbrains.com/idea/

NetBeans

https://netbeans.org

Who this book is for

This book is for enterprise developers and existing Java developers. Basic knowledge of Java is necessary.

Conventions

In this book, you will find a number of text styles that distinguish between different kinds of information. Here are some examples of these styles and an explanation of their meaning.

Code words in text, database table names, folder names, filenames, file extensions, pathnames, dummy URLs, and user input are shown as follows: "Under the subdirectory structure ofC:\chapter8-benchmark\src\main\java\com\packtis theMyBenchmark.javafile."

A block of code is set as follows:

public synchronized void protectedMethod() { . . . }

New terms and important words are shown in bold.

Warnings or important notes appear like this.

Tips and tricks appear like this.

Reader feedback

Feedback from our readers is always welcome. Let us know what you think about this book--what you liked or disliked. Reader feedback is important for us as it helps us develop titles that you will really get the most out of.

To send us general feedback, simply email [email protected], and mention the book's title in the subject of your message.

If there is a topic that you have expertise in and you are interested in either writing or contributing to a book, see our author guide at www.packtpub.com/authors.

Customer support

Now that you are the proud owner of a Packt book, we have a number of things to help you to get the most from your purchase.

Downloading the example code

You can download the example code files for this book from your account at http://www.packtpub.com. If you purchased this book elsewhere, you can visit http://www.packtpub.com/support and register to have the files e-mailed directly to you.

You can download the code files by following these steps:

Hover the mouse pointer on the

SUPPORT

tab at the top.

Click on

Code Downloads & Errata

Enter the name of the book in the

box.

Select the book for which you're looking to download the code files.

Choose from the drop-down menu where you purchased this book from.

Click on

Code Download

Once the file is downloaded, please make sure that you unzip or extract the folder using the latest version of:

WinRAR / 7-Zip for Windows

Zipeg / iZip / UnRarX for Mac

7-Zip / PeaZip for Linux

The code bundle for the book is also hosted on GitHub at https://github.com/PacktPublishing/Mastering-Java-9. We also have other code bundles from our rich catalog of books and videos available at https://github.com/PacktPublishing/. Check them out!

Errata

Although we have taken every care to ensure the accuracy of our content, mistakes do happen. If you find a mistake in one of our books--maybe a mistake in the text or the code--we would be grateful if you could report this to us. By doing so, you can save other readers from frustration and help us improve subsequent versions of this book. If you find any errata, please report them by visiting http://www.packtpub.com/submit-errata, selecting your book, clicking on the Errata Submission Form link, and entering the details of your errata. Once your errata are verified, your submission will be accepted and the errata will be uploaded to our website or added to any list of existing errata under the Errata section of that title.

To view the previously submitted errata, go to https://www.packtpub.com/books/content/support and enter the name of the book in the search field. The required information will appear under the Errata section.

Piracy

Piracy of copyrighted material on the Internet is an ongoing problem across all media. At Packt, we take the protection of our copyright and licenses very seriously. If you come across any illegal copies of our works in any form on the Internet, please provide us with the location address or website name immediately so that we can pursue a remedy.

Please contact us at [email protected] with a link to the suspected pirated material.

We appreciate your help in protecting our authors and our ability to bring you valuable content.

Questions

If you have a problem with any aspect of this book, you can contact us at [email protected], and we will do our best to address the problem.

The Java 9 Landscape

Java is already a fully-grown adult in its own right more than two decades since its first release. With a stunning community of developers and wide adoption in a number of industries, the platform continues to evolve and keep up with the rest of the world in terms of performance, security, and scalability. We will begin our journey by exploring the most significant features introduced in Java 9, what are the biggest drivers behind them, and what more we can expect in subsequent developments of the platform, along with some of the things that did not make it in this release.

In this chapter, we will cover the following topics:

Java 9 at 20,000 feet

Breaking the monolith

Playing around with the Java Shell

Taking control of external processes

Boosting performance with G1

Measuring performance with JMH

Getting ready for HTTP 2.0

Encompassing reactive programming

Expanding the wish list

Java 9 at 20,000 feet

You might be asking yourself--isn't Java 9 just a maintenance release with a set of features that did not make it into Java 8? There is plenty of new stuff in Java 9 that makes it a distinct version in its own right.

Inarguably, the modularization of the Java platform (developed as part of project Jigsaw) is the biggest piece of work that makes it successfully in Java 9. Initially planned for Java 8, but postponed, project Jigsaw is also one of the main reasons why the final release of Java 9 was further postponed. Jigsaw also introduces a few notable changes to the Java platform and is one of the reasons Java 9 is considered a major release. We will explore these features in detail in the subsequent chapters.

The JCP (Java Community Process) provides the mechanisms to turn a set of feature proposals (also known as Java Enhancement Proposals or JEPs) into formal specifications that provide the basis to extend the platform with new functionality. Java 9 is no different in that regard. Apart from the Jigsaw-related Java enhancement proposals, there is a long list of other enhancements that made it in Java 9. Throughout this book, we will discuss the various features in terms of logical groups based on the corresponding enhancement proposals, including the following:

The

Java Shell

(also called

JShell

)--an interactive shell for the Java platform

New APIs to work with operating system processes in a portable manner

The

Garbage-first

(

) garbage collector introduced in Java 7 is made the default garbage collector in Java 9

Adding the

Java Microbenchmark Harness

(

JMH

) tool that can be used to run performance benchmarks against Java applications is included as part of the Java distribution

Support for the HTTP 2.0 and WebSocket standards by means of a new client API

Concurrency enhancements among which is the definition of the

Flow

class, which describes an interface for the reactive streams specification in the Java platform

Some of the initial proposals that were accepted for release 9 did not make it there and were postponed for a later release, along with other interesting things that developers may expect in the future.

You can download the JDK 9 distribution for your system from http://www.oracle.com/technetwork/java/javase/downloads/index.html, if you are eager to get your hands dirty before trying to move through the other chapters and experimenting with the newly introduced samples and concepts.

Breaking the monolith

Over the years, the utilities of the Java platform have continued to evolve and increase, making it one big monolith. In order to make the platform more suitable for embedded and mobile devices, the publication of stripped down editions such as Java CDC and Java ME was necessary. These, however, did not prove to be flexible enough for modern applications with varying requirements in terms of functionality provided by the JDK. In that regard, the need for a modular system came in as a viral requirement, not only to address modularization of the Java utilities (overall, more than 5000 Java classes and 1500 C++ source files with more than 25,0000 lines of code for the Hotspot runtime), but also to provide a mechanism for developers to create and manage modular applications using the same module system used in the JDK. Java 8 provided an intermediate mechanism to enable applications to use only a subset of the APIs provided by the entire JDK, and that mechanism was named compact profiles. In fact, compact profiles also provided the basis for further work that had to be done in order to break dependencies between the various distinct components of the JDK required to enable implementation of a module system in Java.

The module system itself has been developed under the name of project Jigsaw on the basis of which several Java enhancement proposals and a target JSR (376) were formed. Much was put in place to address the requirements of project Jigsaw--there was evidence of concept implementation with more features proposed than the ones that successfully made it into Java 9. Apart from that, a complete restructuring of the JDK code base has been made along with a complete reorganization of the JDK distributable images.

There was considerable controversy in the community as to whether an existing and mature Java module system such as OSGi should be adopted as part of the JDK instead of providing a completely new module system. However, OSGI targets runtime behavior such as the resolution of module dependencies, installation, uninstallation, starting and stopping of modules (also named bundles in terms of OSGI), custom module classloaders, and so on. Project Jigsaw however targets a compile-time module system where resolution of dependencies happen when the application is compiled. Moreover, installing and uninstalling a module as part of the JDK eliminates the need to include it as a dependency explicitly during compilation. Furthermore, loading of module classes is made possible through the existing hierarchy of classloaders (the bootstrap and the extension and system classloaders), although, there was a possibility of using custom module classloaders pretty much similar to the module classloaders of OSGI. The latter was, however, abandoned; we will discuss Java module classloading in more detail when we talk about the details of the module system in Java.

Additional benefits from the Java module system include enhanced security and performance. By modularizing the JDK and applications into Jigsaw modules, we are able to create well-defined boundaries between components and their corresponding domains. This separation of concerns aligns with the security architecture of the platform and is an enabler of better resource utilization. We have dedicated two detailed chapters to all of the preceding points, and to the topic of adopting Java 9 as well, which also requires a degree of understanding on the possible approaches to migrating existing projects to Java 9.

Playing around with the Java Shell

For a long time, there has been no standard shell shipped with the Java programming language to experiment with new language features or libraries or for rapid prototyping. If you wanted to do this, you could write a test application with a main method, compile it with javac, and run it. This could be done either at the command line or using a Java IDE; however, in both cases, this is not as convenient as having an interactive shell for the purpose.

Starting an interactive shell in JDK 9 is as simple as running the following command (assuming the bin directory of your JDK 9 installation is in the current path):

jshell

You may find it somewhat puzzling that an interactive shell has not been introduced earlier in the Java platform as many programming languages, such as Python, Ruby, and a number of others, already come with an interactive shell in their earliest versions; However, this had still not made it on the priority features list for the earlier Java releases, until now, and it is out there and ready for use. The Java shell makes use of a JShell API that provides capabilities to enable autocompletion or evaluation of expressions and code snippets, among other features. A full chapter is dedicated to discussing the details of the Java shell so that developers can make the best use out of it.

Taking control of external processes

Up to JDK 9, if you wanted to create a Java process and handle process input/output, you had to use either the Runtime.getRuntime.exec() method, which allows us to execute a command in a separate OS process and get a java.lang.Process instance over which to provide certain operations in order to manage the external process, or use the new java.lang.ProcessBuilder class with some more enhancements in regard to interacting with the external process and also create a java.lang.Process instance to represent the external process. Both mechanisms were inflexible and also non-portable as the set of commands executed by the external processes were highly dependent on the operating system (additional effort had to be exerted in order to make the particular process operations portable across multiple operating systems). A chapter is dedicated to the new process API, providing developers with the knowledge of creating and managing external processes in a much easier way.

Boosting performance with G1

The G1 garbage collector was already introduced in JDK 7 and is now enabled by default in JDK 9. It is targeted for systems with multiple processing cores and a lot of available memory. What are the benefits of the G1 compared to previous types of garbage collectors? How does it achieve these improvements? Is there a need to manually tune it, and in what scenarios? These, and several more questions regarding G1, will be discussed in a separate chapter.

Measuring performance with JMH

On many occasions, Java applications may suffer from performance degradation. Exacerbating the issue is a lack of performance tests that can provide at least a minimal set of guarantees that performance requirements are met and, moreover, the performance of certain features will not degrade over time. Measuring performance of Java applications is not trivial, especially due to the fact that there is a number of compiler and runtime optimizations that may affect performance statistics. For that reason, additional measures such as warm-up phases and other tricks must be used in order to provide more accurate performance measurements. The Java Microbenchmark Harness is a framework that incorporates a number of techniques along with a convenient API that can be used for this purpose. It is not a new tool, but is included with the distribution of Java 9. If you have not added JMH to your toolbox yet, read the detailed chapter on the usage of JMH in the context of Java 9 application development.

Getting started with HTTP 2.0

HTTP 2.0 is the successor of the HTTP 1.1 protocol, and this new version of the protocol addresses some limitations and drawbacks of the previous one. HTTP 2.0 improves performance in several ways and provides capabilities such as request/response multiplexing in a single TCP connection, sending of responses in a server-push, flow control, and request prioritization, among others.

Java provides the java.net.HttpURLConnection utility that can be used to establish a non-secure HTTP 1.1 connection. However, the API was considered difficult to maintain and further extended with the support for HTTP 2.0 and, so, an entirely new client API was introduced in order to establish a connection via the HTTP 2.0 or the web socket protocols. The new HTTP 2.0 client, along with the capabilities it provides, will be covered in a dedicated chapter.

Encompassing reactive programming

Reactive programming is a paradigm used to describe a certain pattern for propagation of changes in a system. Reactiveness is not built in Java itself, but reactive data flows can be established using third-party libraries such as RxJava or project Reactor (part of the Spring Framework). JDK 9 also addresses the need for an API that aids the development of highly-responsive applications built around the idea of reactive streams by providing the java.util.concurrent.Flow class for the purpose. The Flow class, along with other related changes introduced in JDK 9, will be covered in a separate chapter.

Expanding the wish list

Apart from all of the new stuff in JDK 9, a whole new set of features is expected in future releases of the platform. Among these are the following:

Generics over primitive types

: This is one of the features planned for JDK 10 as part of project Valhalla. Other language enhancements, such as value handles, are already part of Java 9 and will be introduced later in this book.

Reified generics

: This is another featured part of project Valhalla that aims to provide the ability to preserve generic types at runtime. The related goals are listed as follows:

The foreign functional interface aims to introduce a new API to call and manage native functions. The API addresses some of the drawbacks of JNI and especially a lack of simplicity for use by application developers. The foreign functional interface is developed as part of project Panama in the JDK ecosystem.

New money and currency API

(developed under JSR 354) was

initially planned for Java 9, but was postponed.

New lightweight JSON API (developed under JSR 353) was also planned for Java 9, but postponed to Java 10.

These are just some of the new things one may expect in subsequent releases of the JDK. Project Penrose aims to bridge the gap between the module system in Java and the OSGi module system, and to provide different methodologies for interoperability between the two systems.

The Graal VM is another interesting research project that is a potential candidate for subsequent releases of the Java platform. It aims to bring the runtime performance of Java to dynamic languages such as JavaScript or Ruby.

A chapter dedicated to the future of JDK discusses all of these points in detail.

Summary

In this brief introductory chapter, we revealed the small universe of capabilities provided by JDK 9. The module system introduced in this release of the platform is indisputably a cornerstone in the development of Java applications. We also discovered that a number of other major features and changes are introduced in JDK 9 that deserve special attention and will be discussed in great detail in subsequent chapters.

In the next chapter, we will take a look at 26 internal changes to the Java platform.

Discovering Java 9

Java 9 represents a major release and consists of a large number of internal changes to the Java platform. Collectively, these internal changes represent a tremendous set of new possibilities for Java developers, some stemming from developer requests, others from Oracle-inspired enhancements. In this chapter, we will review 26 of the most important changes. Each change is related to a JDK Enhancement Proposal (JEP). JEPs are indexed and housed at openjdk.java.net/jeps/0. You can visit this site for additional information on each JEP.

The JEP program is part of Oracle's support for open source, open innovation, and open standards. While other open source Java projects can be found, OpenJDK is the only one supported by Oracle.

In this chapter, we will cover changes to the Java platform. These changes have several impressive implications, including:

Heap space efficiencies

Memory allocation

Compilation process improvements

Type testing

Annotations

Automated runtime compiler tests

Improved garbage collection

Improved Contended Locking [JEP 143]

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 reference to it. 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 is contended 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 contention:

As you can see in the preceding illustration, any threads in waiting cannot use a locked object until it is released.

Improvement goals

The general goal of JEP 143 was to increase the overall performance of how the JVM manages contention over locked Java object monitors. The improvements to contended locking were all internal to the JVM and do not require any developer actions to benefit from them. The overall improvement goals were related to faster operations. These include:

Faster monitor enter

Faster monitor exit

Faster notifications

The notifications are the notify() and notifyAll() operations that are called when the locked status of an object is changed. Testing this improvement is not something you can easily accomplish. Greater efficiency, at any level, is welcome, so this improvement is one we can be thankful for even without any easily observable testing.

Segmented code cache [JEP 197]

The segmented code cache JEP (197) 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.

A code cache is the area of memory where the Java Virtual Machine stores generated native 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:

Memory allocation

The code heap containing non-method code is for JVM internal code and consists of a 3 MB fixed memory block. The rest of the code cache memory is equally allocated for the profiled code and non-profiled code segments. You have control of this via command-line commands. The following command can be used to define the code heap size for the non-method compiled code:

-XX:NonMethodCodeCodeHeapSize

The following command can be used to define the code heap size for the profiled compiled methods:

-XX:ProfiledCodeHeapSize

The following command can be used to define the code heap size for the non-profiled compiled methods:

-XX:NonProfiledCodeHeapSize

This Java 9 feature certainly stands to improve Java application efficiency. It also impacts other processes that employ the code cache.

Smart Java compilation, phase two [JEP 199]

The JDK Enhancement Proposal 199 is aimed at improving the code compilation process. All Java developers will be familiar with thejavac 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 sjavac adds 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 enough reason to embrace JEP 199.

How will this change how you compile your code? It probably will not, at least not yet. Javac will remain the default compiler. While sjavac offers efficiencies regarding incremental builds, Oracle has deemed it to not have sufficient stability to become part of the standard compilation workflow.

You can read more information about the smart javac wrapper tool here: http://cr.openjdk.java.net/~briangoetz/JDK-8030245/webrev/src/share/classes/com/sun/tools/sjavac/Main.java-.html.

Resolving Lint and Doclint warnings [JEP 212]

Do not worry if you are not familiar with Lint or Doclint in Java. As you can determine from the section title, they are sources that report warnings to javac. Let's take a look at each one:

Lint

analyzes byte code 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.

You can read more about Lint here:https://en.wikipedia.org/wiki/Lint_(software).

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.

A comprehensive list of the Lint and Doclint warnings can be reviewed in the https://bugs.openjdk.java.net

Tausende von E-Books und Hörbücher

Ihre Zahl wächst ständig und Sie haben eine Fixpreisgarantie.

Sie haben über uns geschrieben:

Mastering Java 9 E-Book

Dr. Edward Lavieri

About This Book

Who This Book Is For

What You Will Learn

In Detail

Style and approach

Mastering Java 9

Credits

About the Authors

About the Reviewer

www.PacktPub.com

Why subscribe?

Customer Feedback

Table of Contents

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Downloading the example code

Errata

Piracy

Questions

The Java 9 Landscape

Java 9 at 20,000 feet

Breaking the monolith

Playing around with the Java Shell

Taking control of external processes

Boosting performance with G1

Measuring performance with JMH

Getting started with HTTP 2.0

Encompassing reactive programming

Expanding the wish list

Summary

Discovering Java 9

Improved Contended Locking [JEP 143]

Improvement goals

Segmented code cache [JEP 197]

Memory allocation

Smart Java compilation, phase two [JEP 199]

Resolving Lint and Doclint warnings [JEP 212]