To follow the instructions in this chapter, you will need the following:

• A computer with either Windows, macOS, or Linux installed
• The current version of the Java SDK
• Preferably, a code editor or integrated development environment (IDE) (such as Visual Studio Code, NetBeans, Eclipse, or IntelliJ IDEA)

The finished code for this chapter can be found here: https://github.com/PacktPublishing/High-Performance-with-Java/tree/main/Chapter01.

Important note

This book is based on Java 21 and the Java Development Kit (JDK) 21.0.1. It also uses the IntelliJ IDEA Community Edition IDE, running on macOS.

This chapter contains code examples that you can use to follow along with and experiment with. So, you will want to ensure your system is properly prepared.

Start by downloading and installing your IDE of choice. Here are a couple of options:

• Visual Studio Code (https://code.visualstudio.com/download)
• NetBeans (https://netbeans...

At the core, the JVM sits between your Java bytecode and your computer. As illustrated next, we develop our Java source code in an IDE, and our work is saved as .java files. We use the Java compiler to convert our Java source code to bytecode; the resulting files are .class files. We then use the JVM to run our bytecode on our computer:

Figure 1.1 – Java application workflow

It is important to realize that Java is different from typical compile-and-execute languages where source code is fed into a compiler, which then produces a .exe file (for Windows), a .app file (for (macOS), or ELF files (for Linux). This impressive process is much more complex than it seems.

Let’s take a closer look at what is going on with regard to the JVM, using a basic example. In the following code, we implement a simple loop that prints to the console. It is presented so that we can see how the JVM handles Java code:

// Chapter1
// Example...

Java developers have long enjoyed the JVM’s ability to manage memory, including allocation and deallocation. The allocation component of memory management is straightforward and not wrought with inherent problems. The area that is most important is freeing previously allocated memory that is no longer needed by the application. This is referred to as deallocation or garbage collection. While not unique to Java programming language, its JVM does a wonderful job with garbage collection. This section takes a detailed look at JVM’s garbage collection.

The garbage collection process

The following example is the creation of two objects, making them reference each other, and then nullifying them both. Once they are nullified, they are no longer reachable, despite that they reference each other. This makes them eligible for garbage collection:

public class Main {
    public static void main(String[] args) {
    ...

There are three key components of the JVM: a class loader that initializes and links classes and interfaces; runtime data, which includes memory allocation; and the execution engine. This latter component, the execution engine, is the focus of this section.

The core responsibility of the execution engine is to convert bytecode so that it can be executed on the host central processing unit (CPU). There are three primary implementations of this process:

• Interpretation
• Ahead-of-Time (AOT) compilation
• JIT compilation

We will take a cursory look at interpretation and AOT compilation before diving into JIT compilation optimizations.

Interpretation

Interpretation is a technique that the JVM can use to read and execute bytecode without converting it into machine code native to the host CPU. We can invoke this mode by using the java command in a terminal window. Here is an example:

$ java Main.java

The only real advantage of using...

By now, you should have an appreciation of the complexities of the JVM and how it works. This chapter’s coverage included the javac and javap command-line tools to create and analyze bytecode. The JVM’s garbage collection function was also examined through the lens of application performance. Lastly, the optimization of JIT compilation was covered.

The JVM is 29 years old, as of this book’s publication date, and it has come a long way since its initial release. In addition to continual improvements and optimizations, the JVM can even support additional languages (for example, Kotlin and Scala). Java developers interested in continual performance improvement of their Java applications should stay abreast of JVM updates.

With a solid understanding of the JVM, we turn our focus to data structures in the next chapter. Our focus will be on using data structures optimally as part of our high-performance strategy.