Tools for Developing and Launching Products on Java Virtual Machine

It’s no secret that Java is one of the most popular programming languages in the world right now. It was officially launched on May 23, 1995. This article is about the basics and fundamental tools of Java, that will come in handy for beginner Java developers, while senior developers will be able to brush up on their knowledge. 1. JDK, JRE, JVM is the official development kit for building applications using the Java programming language. The Kit includes and . Java Development Kit Java development tools Java Runtime Environment Java development tools include around 40 different tools such as: (a compiler), ( launcher for Java applications), (class file disassembler), (java debugger), and others. javac java javap jdb Java Runtime Environment is a set of software tools needed to launch a compiled Java program. It includes and . Java Virtual Machine Java Class Library JVM is a program responsible for the execution of a bytecode. The first advantage of the JVM is a so-called ‘Write once, run anywhere’ rule. It means that an app developed on Java will run on any platform. This is an advantage of both JVM and Java itself. There are many JVM implementations both commercial and open source. One of the reasons for creating new JVMs is to increase performance for a particular platform. Each JVM is developed for a platform separately. And there is an opportunity to develop the JVM so that it will work faster on a particular platform. The most widespread JVM implementation is the JVM Hotspot by OpenJDK. There are also such implementations as IBM J9, Excelsior JET. 2. Code execution on JVM According to , you need to complete the 3 following stages to get a code running on the JVM: Java SE specifications a bytecode and creating a Class instance Downloading Linking: : at this stage, the correctness of instructions, the possibility of stack overflow on a given code section, the compatibility of variable types are being checked; verification is done once for each class; verification : at this stage, according to the specifications, memory for static fields is allocated and their initialization is performed; preparation : at this stage, permission of symbolic links happens (when we open files with the .class extension in a bytecode, here we see numerical values instead of symbolic links) resolution of the received Class object at the final stage, the сlass we created is initialized, and the JVM begins its execution. Initializing 3. Java classloaders and their hierarchy Classloaders are special classes that are a part of the JVM. They load classes into Java memory and make them available for execution. The classloaders work with all classes: those that were written by us, and those that are directly needed for Java. Imagine the situation, when you developed an app, and in addition to standard classes, there are lots of personalized classes. How will the JVM work? There is such a ‘function’ in Java, as lazy loading, which means that the class loading will be performed only when it is first referenced. The first classloader is the . It is developed using C++ Bootstrap is a basic classloader that loads all system classes from archive. At the same time, there is a slight difference between loading classes from and our classes. When the JVM loads classes from rt.jar, it doesn’t perform all the verification stages, since the JVM is initially aware of the fact that classes from are already verified. It means that you should not place any of your own files into that archive. Bootstrap rt.jar rt.jar rt.jar The next classloader is the . It loads Java extension classes from folder. Let’s say, you want a certain class to load every time JVM starts. In order to enable it, you can copy a source class file to that folder, and it will be loaded automatically. Extension classloader jre/lib/ext Another classloader is the . It loads classes from the classpath we indicated when launching an application. System classloader The process of classloading is performed by the following hierarchy: First of all, we request a cache search of the System Classloader that contains the classes that were previously loaded; If the class was not found in the System Classloader cache, we look for it in the cache of the Extension classloader; If the class was not found in the Extension classloader cache, we request it in the Bootstrap loader cache. If the class was not found in the Bootstrap cache, Bootstrap tries to load this class. If the loading failed, the Bootstrap delegates loading to the Extension classloader. If the class is then loaded, it stays in the cache of the Extension classloader, and the class loading is complete. 4. Java class structure. Loading of Java classes Here we proceed directly to the structure of class files. One class written on Java is compiled into one file with the .class extension. If our Java file has several classes, it can be compiled into several files with the .class extension respectively, namely into bytecode files of these classes. All numbers, strings, class references, fields, and methods are stored in the — the memory area. The class description is stored in the same area and contains a name, modificators, super-class, super-interfaces, fields, methods, and attributes. Attributes, in their turn, can contain any additional information. Сonstant pool Metaspace Thus, when loading classes the following steps are performed: reading or verification of format correctness of a class-file; creating a class instance in the Constant pool area; loading of super-classes and super-interfaces; if they are not loaded, the class itself won’t be loaded either. 5. Bytecode execution on JVM First of all, JVM can a bytecode in order to execute it. Bytecode Interpretation is rather a slow process. During this process, an “runs” through the class-file line by line, and translates it into commands understandable by the JVM. interpret interpreter The JVM can also (or compile) a bytecode into a machine code, that will be directly executed on the computer’s processor. translate Commands that are executed frequently, won’t be interpreted, they will be translated automatically. 6. Compilation is a programme that translates a source code from a high-level programming language to a machine code understandable for a computer. The Compiler Compilers are divided into: Non-optimizing (e.g. ): works fast, but generates non-optimal code; Simple optimizing compilers Hotspot Client (e.g. ): performs complex optimizing transformations before generating a bytecode. Complex optimizing compilers Hotspot Server Compilers can be also divided by the moment of compilation: They work along with the program, thereby affecting its performance. It’s important for dynamic compilers to work on code that is executed frequently. During the program’s execution, JVM understands, which particular code is executed more often, and to avoid constant interpretation of this code, the virtual machine translates it into commands, that will be directly executed on the processor. Dynamic or Just-In-Time compilers While the compiling process is performed for a longer period, static compilers generate the optimized code for its execution. Static compilers do not need any resources during the execution of a program and each method is compiled using optimizations. Static compilers 7. Java memory management The is a temporary memory space in Java. Stack memory is always referenced in LIFO order — “last in, first out”. Stack The Stack is needed to store methods. Variables in the stack are stored until the method they were created in will execute. When a new method is invoked, a new frame of memory will be created on the top of the Stack. As soon as method ends, that block will be erased. The next method invoked will use that empty block. If the stack memory is full, Java will throw a exception. For example, this can occur if there is a recursive function that invokes itself, and the Stack memory has overflowed. xjava.lang.StackOverFlowError Key Stack features: Stack is filled in and cleaned up as new methods are invoked and completed; Access to this memory is considerably fast when compared to heap memory; The size of the Stack is defined by the OS; This memory is thread-safe as each thread operates in its own stack. Another memory space in Java is the . It is used to store objects and classes. New objects are always created in the Heap, while references to these objects are stored in the Stack. Objects stored in the Heap are globally accessible, it means that they can be accessed throughout the application. Heap The Heap is divided into several parts called generations: is a field, where recently created objects are stored; Young generation is a field, where long-life objects are stored; Old (tenured) generation Before Java 8, there was one more memory space — Permanent generation. it contained meta-information about classes, methods, statistical variables. After Java 8 was invented, all this information then became stored separately in the Metaspace.In contrast, Metaspace has a dynamic size, and during its execution, it can expand up to the memory size of the JVM. Why was the decision taken to get rid of Permanent generation? First of all, it was because of the error connected with memory overflow. Since the Perm had a constant size and could not expand dynamically, sooner or later the memory ran out, an error was thrown and application crashed. In contrast, Metaspace has a dynamic size, and during its execution, it can expand up to the memory size of the JVM. Key Heap features: If Heap space is full, Java throws java.lang.OutOfMemoryError; Access to the Heap is relatively slower in comparison to the Stack; To remove unused objects from the memory in the Heap, a Garbage collector is used; Unlike stack, a heap isn’t thread-safe and needs to be guarded by properly synchronizing the code. Based on the information above, let’s take a look at the process of memory management with a simple example: public { public main( [] args) { int id = ; pName = ; Person p = ; p = Person(id, pName); } } { int pid; name; } class App static void String 23 String "Jon" null new class Person String // constructors, getters/setters Now, let’s analyze this step by step: 1. Upon entering the main() method, a space in stack memory would be created to store primitives and references of this method: The primitive value of the integer will be stored directly in the stack memory id The reference variable p of the type Person will also be created in the stack memory, which will point to the actual object in the heap 2. The call to the parameterized constructor from will allocate further memory on top of the previous stack. This will store: Person(int, String) main() object reference of the calling object in stack memory This The primitive value in the stack memory id The reference variable of argument which will point to the actual string from the string pool in the heap memory String personName 3. This default constructor is further calling method, for which further allocation will take place in stack memory on top of the previous one. This will again store variables in the manner described above. 4. However, for the newly created object p of type Person, all instance variables will be stored in the heap memory. setPersonName() This allocation is explained in the following diagram: 8. Garbage collection in Java is a programme that works in JVM and is intended to delete objects that are no longer used or needed. Garbage collector Different JVMs can have different algorithms of garbage collection, so there are a variety of different garbage collectors in Java. Right now, we will talk about the simplest garbage collector — Serial GC. In order to request a garbage collecting process, we use the command. System.gc() As already mentioned, the Heap memory is divided into 2 sections called Generations: New generation and Old generation. New generation includes 3 regions: , and . Eden, Survivor 0 Survivor 1 Old generation includes region. the Tenured So what happens when we create a new object in Java? First of all this object goes to the . If we have created a lot of objects and there is no more memory for new objects, the garbage collector is triggered and frees up memory: it cleans up the region and relocates all surviving objects to the region. Thus, the is completely cleaned. Eden Eden Survivor 0 Eden If the was filled with new objects again, the garbage collector begins to work with both region and region. After the collection, the surviving objects will go to another region — , while the two other regions will remain empty. Eden Eden Survivor 0 Survivor 1 During the following garbage collection, the region will be chosen as a target region again. This is why it’s important that with one of the regions — Survivor 0 or Survivor 1 — is always empty. Survivor 0 JVM monitors the objects that are constantly copied and relocated from one region to another. So, in order to optimize this mechanism, after a certain threshold, the garbage collector moves such objects to the region. Tenured When the Tenured region has overflowed, or full garbage collection happens. Mark-Sweep-Compact During this mechanism, the Tenured region is cleaned from unused objects and is defragmented, i.e. sequentially filled with necessary objects. In this article, I covered basic tools of Java: JVM, JRE, JDK, the main principles and stages of code execution on JVM, compilation, memory management, and garbage collection mechanism. * The article is based on the report of Eugene Fraiman, IntexSoft Java Developer.