Java Virtual Machinei

Java Virtual MachineAbout the TutorialJava Virtual Machine is a virtual machine, an abstract computer that has its own ISA, ownmemory, stack, heap, etc. It is an engine that manages system memory and drives Javacode or applications in run-time environment. It runs on the host Operating system andplaces its demands for resources to it.AudienceThis tutorial is designed for software professionals who want to run their Java code andother applications on any operating system or device, and to optimize and manageprogram memory.PrerequisitesBefore you start to learn this tutorial, we assume that you have a basic understanding ofJava Programming. If you are new to these concepts, we suggest you to go through theJava programming tutorial first to get a hold on the topics mentioned in this tutorial.Copyright & Disclaimer Copyright 2019 by Tutorials Point (I) Pvt. Ltd.All the content and graphics published in this e-book are the property of Tutorials Point (I)Pvt. Ltd. The user of this e-book is prohibited to reuse, retain, copy, distribute or republishany contents or a part of contents of this e-book in any manner without written consentof the publisher.We strive to update the contents of our website and tutorials as timely and as precisely aspossible, however, the contents may contain inaccuracies or errors. Tutorials Point (I) Pvt.Ltd. provides no guarantee regarding the accuracy, timeliness or completeness of ourwebsite or its contents including this tutorial. If you discover any errors on our website orin this tutorial, please notify us at [email protected]

Java Virtual MachineTable of ContentsAbout the Tutorial . iiAudience . iiPrerequisites . iiCopyright & Disclaimer . iiTable of Contents . iii1.Java Virtual Machine – Introduction . 12.Java Virtual Machine — Architecture . 23.Java Virtual Machine — Class Loader . 34.Java Virtual Machine — Runtime Data Areas . 4Garbage Collection . 55.Java Virtual Machine — The JIT Compiler. 6Compiled vs. Interpreted Languages . 6HotSpots . 66.Java Virtual Machine — Compilation Levels . 9Client vs. Server JIT . 9Tiered Compilation . 97.Java Virtual Machine — 32b vs. 64b JVMs. 118.Java Virtual Machine — JIT Optimisations . 12Method Inlining . 12Unreachable and Dead Code Elimination . 12Constant Folding . 139.Java Virtual Machine — Garbage Collection . 14Memory Coalescing . 1510. Java Virtual Machine — Generational GCs . 16Serial GC . 17Throughput GC . 17iii

Java Virtual MachineCMS Collector . 18G1 GC . 1911. Java Virtual Machine — Tuning the GC . 20Heap Size . 20Generation Sizes . 21Permagen and Metaspace . 2112. Java Virtual Machine — Memory Leak in Java . 23iv

1. Java Virtual Machine – IntroductionJava Virtual MachineThe JVM is a specification, and can have different implementations, as long as they adhereto the specs. The specs can be found in the below /html/jvms-2.htmlOracle has its own JVM implementation (called the HotSpot JVM), the IBM has its own (theJ9 JVM, for example).The operations defined inside the spec are given below (source: Oracle JVM Specs, seethe above link): The ‘class’ file format Data types Primitive types and values Reference types and values Run-time data areas Frames Representation of objects Floating-point arithmetic Special methods Exceptions Instruction set summary Class libraries Public design, private implementationThe JVM is a virtual machine, an abstract computer that has its own ISA, own memory,stack, heap, etc. It runs on the host OS and places its demands for resources to it.1

2. Java Virtual Machine — ArchitectureJava Virtual MachineThe architecture of the HotSpot JVM 3 is shown below:The execution engine comprises of the garbage collector and the JIT compiler. The JVMcomes in two flavors: client and server. Both of these share the same runtime code butdiffer in what JIT is used. We shall learn more on this later. The user can control whatflavor to use by specifying the JVM flags -client or -server. The server JVM has beendesigned for long-running Java applications on servers.The JVM comes in 32b and 64b versions. The user can specify what version to use by using-d32 or -d64 in the VM arguments. The 32b version could only address up to 4G ofmemory. With critical applications maintaining large datasets in memory, the 64b versionmeets that need.2

3. Java Virtual Machine — Class LoaderJava Virtual MachineThe JVM manages the process of loading, linking and initializing classes and interfaces ina dynamic manner. During the loading process, the JVM finds the binaryrepresentation of a class and creates it.During the linking process, the loaded classes are combined into the run-time stateof the JVM so that they can be executed during the initialization phase. The JVMbasically uses the symbol table stored in the run-time constant pool for the linking process.Initialization consists of actually executing the linked classes.Types of LoadersThe BootStrap class loader is on the top of the class loader hierarchy. It loads thestandard JDK classes in the JRE’s lib directory.The Extension class loader is in the middle of the class loader hierarchy and is theimmediate child of the bootstrap class loader and loads the classes in the JRE’s lib\extdirectory.The Application class loader is at the bottom of the class loader hierarchy and is theimmediate child of the application class loader. It loads the jars and classes specified bythe CLASSPATH ENV variable.LinkingThe linking process consists of the following three steps:Verification: This is done by the Bytecode verifier to ensure that the generated .classfiles (the Bytecode) are valid. If not, an error is thrown and the linking process comes toa halt.Preparation: Memory is allocated to all static variables of a class and they are initializedwith the default values.Resolution: All symbolic memory references are replaced with the original references. Toaccomplish this, the symbol table in the run-time constant memory of the method area ofthe class is used.InitializationThis is the final phase of the class-loading process. Static variables are assigned originalvalues and static blocks are executed.3

4. Java Virtual Machine — Runtime Data AreasJava Virtual MachineThe JVM spec defines certain run-time data areas that are needed during the execution ofthe program. Some of them are created while the JVM starts up. Others are local to threadsand are created only when a thread is created (and destroyed when the thread isdestroyed). These are listed below:PC (Program Counter) RegisterIt is local to each thread and contains the address of the JVM instruction that the threadis currently executing.StackIt is local to each thread and stores parameters, local variables and return addressesduring method calls. A StackOverflow error can occur if a thread demands more stackspace than is permitted. If the stack is dynamically expandable, it can still throwOutOfMemoryError.HeapIt is shared among all the threads and contains objects, classes’ metadata, arrays, etc.,that are created during run-time. It is created when the JVM starts and is destroyed whenthe JVM shuts down. You can control the amount of heap your JVM demands from the OSusing certain flags (more on this later). Care has to be taken not to demand too less ortoo much of the memory, as it has important performance implications. Further, the GCmanages this space and continually removes dead objects to free up the space.Method AreaThis run-time area is common to all threads and is created when the JVM starts up. Itstores per-class structures such as the constant pool (more on this later), the code forconstructors and methods, method data, etc. The JLS does not specify if this area needsto be garbage collected, and hence, implementations of the JVM may choose to ignore GC.Further, this may or may not expand as per the application’s needs. The JLS does notmandate anything with regard to this.Run-Time Constant PoolThe JVM maintains a per-class/per-type data structure that acts as the symbol table (oneof its many roles) while linking the loaded classes.Native Method StacksWhen a thread invokes a native method, it enters a new world in which the structures andsecurity restrictions of the Java virtual machine no longer hamper its freedom. A nativemethod can likely access the runtime data areas of the virtual machine (it depends uponthe native method interface), but can also do anything else it wants.4

Java Virtual MachineGarbage CollectionThe JVM manages the entire lifecycle of objects in Java. Once an object is created, thedeveloper need not worry about it anymore. In case the object becomes dead (that is,there is no reference to it anymore), it is ejected from the heap by the GC using one ofthe many algorithms – serial GC, CMS, G1, etc.During the GC process, objects are moved in memory. Hence, those objects are not usablewhile the process is going on. The entire application has to be stopped for the duration ofthe process. Such pauses are called ‘stop-the-world’ pauses and are a huge overhead. GCalgorithms aim primarily to reduce this time. We shall discuss this in great detail in thefollowing chapters.Thanks to the GC, memory leaks are very rare in Java, but they can happen. We will seein the later chapters how to create a memory leak in Java.5

5. Java Virtual Machine — The JIT CompilerJava Virtual MachineIn this chapter, we shall learn about JIT compiler, and the difference between compiledand interpreted languages.Compiled vs. Interpreted LanguagesLanguages such as C, C and FORTRAN are compiled languages. Their code is deliveredas binary code targeted at the underlying machine. This means that the high-level code iscompiled into binary code at once by a static compiler written specifically for the underlyingarchitecture. The binary that is produced will not run on any other architecture.On the other hand, interpreted languages like Python and Perl can run on any machine,as long as they have a valid interpreter. It goes over line-by-line over the high-level code,converting that into binary code.Interpreted code is typically slower than compiled code. For example, consider a loop. Aninterpreted will convert the corresponding code for each iteration of the loop. On the otherhand, a compiled code will make the translation only one. Further, since interpreters seeonly one line at a time, they are unable to perform any significant code such as, changingthe order of execution of statements like compilers.We shall look into an example of such optimization below:Adding two numbers stored in memory. Since accessing memory can consumemultiple CPU cycles, a good compiler will issue instructions to fetch the data from memoryand execute the addition only when the data is available. It will not wait and in themeantime, execute other instructions. On the other hand, no such optimization would bepossible during interpretation since the interpreter is not aware of the entire code at anygiven time.But then, interpreted languages can run on any machine that has a valid interpreter ofthat language.Is Java Compiled or Interpreted?Java tried to find a middle ground. Since the JVM sits in between the javac compiler andthe underlying hardware, the javac (or any other compiler) compiler compiles Java codein the Bytecode, which is understood by a platform specific JVM. The JVM then compilesthe Bytecode in binary using JIT (Just-in-time) compilation, as the code executes.HotSpotsIn a typical program, there’s only a small section of code that is executed frequently, andoften, it is this code that affects the performance of the whole application significantly.Such sections of code are called HotSpots.If some section of code is executed only once, then compiling it would be a waste of effort,and it would be faster to interpret the Bytecode instead. But if the section is a hot sectionand is executed multiple times, the JVM would compile it instead. For example, if a method6

Java Virtual Machineis called multiple times, the extra cycles that it would take to compile the code would beoffset by the faster binary that is generated.Further, the more the JVM runs a particular method or a loop, the more information itgathers to make sundry optimizations so that a faster binary is generated.Let us consider the following code:for(int i 0 ; I 100; i ) {System.out.println(obj1.equals(obj2)); //two objects}If this code is interpreted, the interpreter would deduce for each iteration that classes ofobj1. This is because each class in Java has an .equals() method, that is extended fromthe Object class and can be overridden. So even if obj1 is a string for each iteration, thededuction will still be done.On the other hand, what would actually happen is that the JVM would notice that for eachiteration, obj1 is of class String and hence, it would generate code corresponding to the.equals() method of the String class directly. Thus, no lookups will be required, and thecompiled code would execute faster.This kind of behavior is only possible when the JVM knows how the code behaves. Thus, itwaits before compiling certain sections of the code.Below is another example:int sum 7;for(int i 0 ; i 100; i ) {sum i;}An interpreter, for each loop, fetches the value of ‘sum’ from the memory, adds ‘I’ to it,and stores it back into memory. Memory access is an expensive operation and typicallytakes multiple CPU cycles. Since this code runs multiple times, it is a HotSpot. The JIT willcompile this code and make the following optimization.A local copy of ‘sum’ would be stored in a register, specific to a particular thread. All theoperations would be done to the value in the register and when the loop completes, thevalue would be written back to the memory.What if other threads are accessing the variable as well? Since updates are being done toa local copy of the variable by some other thread, they would see a stale value. Threadsynchronization is needed in such cases. A very basic sync primitive would be to declare‘sum’ as volatile. Now, before accessing a variable, a thread would flush its local registersand fetch the value from the memory. After accessing it, the value is immediately writtento the memory.Below are some general optimizations that are done by the JIT compilers: Method inlining Dead code elimination Heuristics for optimizing call sites7

Java Virtual Machine Constant folding8

6. Java Virtual Machine — Compilation LevelsJava Virtual MachineJVM supports five compilation levels: Interpreter C1 with full optimization (no profiling) C1 with invocation and back-edge counters (light profiling) C1 with full profiling C2 (uses profiling data from the previous steps)Use -Xint if you want to disable all JIT compilers and use only the interpreter.Client vs. Server JITUse -client and -server to activate the respective modes.The client compiler (C1) starts compiling code sooner than the server compiler (C2). So,by the time C2 has started compilation, C1 would have already compiled sections of code.But while it waits, C2 profiles the code to know about it more than the C1 does. Hence,the time it waits if offset by the optimizations can be used to generate a much fasterbinary. From the perspective of a user, the trade-off is between the startup time of theprogram and the time taken for the program to run. If startup time is the premium, thenC1 should be used. If the application is expected to run for a long time (typical ofapplications deployed on servers), it is better to use C2 as it generates much faster codewhich greatly offsets any extra startup time.For programs such as IDEs (NetBeans, Eclipse) and other GUI programs, the startup timeis critical. NetBeans might take a minute or longer to start. Hundreds of classes arecompiled when programs such as NetBeans are started. In such cases, C1 compiler is thebest choice.Note that there are two versions of C1: 32b and 64b. C2 comes only in 64b.Tiered CompilationIn older versions on Java, the user could have selected one of the following options: Interpreter (-Xint) C1 (-client) C2 (-server)It came in Java 7. It uses the C1 compiler to startup, and as the code gets hotter, switchesto the C2. It can be activated with the following JVM options: -XX: TieredCompilation.The default value is set to false in Java 7, and to true in Java 8.9

Java Virtual MachineOf the five tiers of compilation, tiered compilation uses 1 - 4 - 5.10

7. Java Virtual Machine — 32b vs. 64b JVMsJava Virtual MachineOn a 32b machine, only the 32b version of the JVM can be installed. On a 64b machine,the user has a choice between the 32b and the 64b version. But there are certain nuancesto this that can affect how our Java applications perform.If the Java application uses less than 4G of memory, we should use the 32b JVM even on64b machines. This is because memory references in this case would only be 32b andmanipulating them would be less expensive than manipulating 64b addresses. In this case,the 64b JVM would perform worse even if we are using OOPS (ordinary object pointers).Using OOPS, the JVM can use 32b addresses in the 64b JVM. However, manipulating themwould be slower than the real 32b references since the underlying native references wouldstill be 64b.If our application is going to consume more than 4G memory, we will have to use the 64bversion as the 32b references can address no more than 4G of memory. We can have boththe versions installed on the same machine and can switch between them using the PATHvariable.11

8. Java Virtual Machine — JIT OptimisationsJava Virtual MachineIn this chapter, we shall learn about JIT Optimisations.Method InliningIn this optimization technique, the compiler decides to replace your function calls with thefunction body. Below is an example for the same:int sum3;static int add(int a, int b) {return a b;}public static void main(String args) {sum3 add(5,7) add(4,2);}//after method inliningpublic static void main(String args) {sum3 5 7 4 2;}Using this technique, the compiler saves the machine from the overhead of making anyfunction calls (it requires pushing and popping parameters to the stack). Thus, thegenerated code runs faster.Method inlining can only be done for non-virtual functions (functions that are notoverridden). Consider what would happen if the ‘add’ method was over-ridden in a subclass and the type of the object containing the method is not known until runtime. In thiscase, the compiler would not know what method to inline. But if the method was markedas ‘final’, then the compiler would easily know that it can be inline because it cannot beover-ridden by any sub-class. Note that it is not at all guaranteed that a final methodwould be always in-lined.Unreachable and Dead Code EliminationUnreachable code is code that cannot be reached at by any possible execution flows. Weshall consider the following example:void foo() {12

Java Virtual Machineif (a) return;else return;foobar(a,b); //unreachable code, compile time error}Dead code is also unreachable code, but the compiler does spit an error out in this case.Instead, we just get a warning. Each block of code such as constructors, functions, try,catch, if, while, etc., have their own rules for unreachable code defined in the JLS (JavaLanguage Specification).Constant FoldingTo understand the constant folding concept, see the below int num 5;int b num * 6;//compile-time constant, num never changes//compiler would assign b a value of 30.13

9. Java Virtual Machine — Garbage CollectionJava Virtual MachineThe lifecycle of a Java object is managed by the JVM. Once an object is created by theprogrammer, we need not worry about the rest of its lifecycle. The JVM will automaticallyfind those objects that are not in use anymore and reclaim their memory from the heap.Garbage collection is a major operation that JVM does and tuning it for our needs can givea massive performance boosts to our application. There are a variety of garbage collectionalgorithms that are provided by modern JVMs. We need to be aware of our application’sneeds to decide on which algorithm to use.You cannot deallocate an object programmatically in Java, like you can do in non-GClanguages like C and C . Therefore, you cannot have dangling references in Java.However, you may have null references (references that refer to an area of memory wherethe JVM won’t ever store objects). Whenever a null reference is used, the JVM throws aNullPointerException.Note that while it is rare to find memory leaks in Java programs thanks to the GC, they dohappen. We will create a memory leak at the end of this chapter.The following GCs are used in modern JVMs: Serial collector Throughput collector CMS collector G1 collectorEach of the above algorithms does the same task – finding objects that are no longer inuse and reclaiming the memory that they occupy in the heap. One of the naïve approachesto this would be to count the number of references that each object has and free it up assoon as the number of references turn 0 (this is also known as reference counting). Whyis this naïve? Consider a circular linked list. Each of its nodes will have a reference to it,but the entire object is not being referenced from anywhere, and should be freed, ideally.The JVM not only frees the memory, but also coalesces small memory chucks into biggerones it. This is done to prevent memory fragmentation.On a simple note, a typical GC algorithm does the following activities: Finding unused objects Freeing the memory that they occupy in the heap Coalescing the fragmentsThe GC has to stop application threads while it is running. This is because it moves theobjects around when it runs, and therefore, those objects cannot be used. Such stops arecalled ‘stop-the-world pauses and minimizing the frequency and duration of these pausesis what we aim while tuning our GC.14

Java Virtual MachineMemory CoalescingA simple demonstration of memory coalescing is shown below:The shaded portion are objects that need to be freed. Even after when all the space isreclaimed, we can only allocate an object of maximum size 75Kb. This is even after wehave 200Kb of free space as shown below:15

10. Java Virtual Machine — Generational GCsJava Virtual MachineMost JVMs divide the heap into three generations: the young generation (YG), the oldgeneration (OG) and permanent generation (also called tenured generation).What are the reasons behind such thinking?Empirical studies have shown that most of the objects that are created have very s you can see that as more and more objects are allocated with time, the number ofbytes surviving becomes less (in general). Java objects have high mortality rate.We shall look into a simple example. The String class in Java is immutable. This meansthat every time you need to change the contents of a String object, you have to create anew object altogether. Let us suppose you make changes to the string 1000 times in aloop as shown in the below code:String str “G11 GC”;for(int i 0 ; i 1000; i ) {str str String.valueOf(i);}In each loop, we create a new string object, and the string created during the previousiteration becomes useless (that is, it is not referenced by any reference). T lifetime of thatobject was just one iteration – they’ll be collected by the GC in no time. Such short-lived16

Java Virtual Machineobjects are kept in the young generation area of the heap. The process of collecting objectsfrom the young generation is called minor garbage collection, and it always causes a ‘stopthe-world’ pause.As the young generation gets filled up, the GC does a minor garbage collection. Deadobjects are discarded, and live objects are moved to the old generation. The applicationthreads stop during this process.Here, we can see the advantages that such a generation design offers. The younggeneration is only a small part of the heap and gets filled up quickly. But processing ittakes a lot lesser time than the time taken to process the entire heap. So, the ‘stop-theworld’ pauses in this case are much shorter, although more frequent. We should alwaysaim for shorter pauses over longer ones, even though they might be more frequent. Weshall discuss this in detail in later sections of this tutorial.The young generation is divided into two spaces: eden and survivor space. Objects thathave survived during the collection of eden are moved to survivor space, and those whosurvive the survivor space are moved to the old generation. The young generation iscompacted while it is collected.As objects are moved to the old generation, it fills up eventually, and has to be collectedand compacted. Different algorithms take different approaches to this. Some of them stopthe application threads (which leads to a long ‘stop-the-world’ pause since the oldgeneration is quite big in comparison to the young generation), while some of them do itconcurrently while the application threads keep running. This process is called full GC. Twosuch collectors are CMS and G1.Let us now analyze these algorithms in detail.Serial GCit is the default GC on client-class machines (single processor machines or 32b JVM,Windows). Typically, GCs are heavily multithreaded, but the serial GC is not. It has a singlethread to process the heap, and it will stop the application threads whenever it is doing aminor GC or a major GC. We can command the JVM to use this GC by specifying the flag:-XX: UseSerialGC. If we want it to use some different algorithm, specify the algorithmname. Note that the old generation is fully compacted during a major GC.Throughput GCThis GC is default on 64b JVMs and multi-CPU machines. Unlike the serial GC, it usesmultiple threads to process the youn

Java Virtual Machine ii About the Tutorial Java Virtual Machine is a virtual machine, an abstract computer that has its own ISA, own . All the content and graphics published in this e-book are the property of Tutorials Point (I) Pvt. Ltd. The user of this e-book is prohibited to reuse, retain, copy, distribute or republish .