Java Memory Management

Garbage Collection:

Garbage Collection is the process of freeing space in the heap for the allocation of new objects. One of the best features of Java is automatic garbage collection. 


Garbage Collector is the program running in the background that looks into all the objects in the memory and find out objects that are not referenced by any part of the program. All these unreferenced objects are deleted and space is reclaimed for allocation to other objects. One of the basic ways of garbage collection involves three steps:


Marking: This is the first step where the garbage collector identifies which objects are in use and which ones are not in use


Normal Deletion: Garbage collector removes the unused objects and reclaims the free space to be allocated to other objects

Deletion with compacting: For better performance, after deleting unused objects, all the survived objects can be moved to be together. This will increase the performance of allocation of memory to newer objects


Java Memory Management.

 

The JVM Heap is physically divided into two parts.

1. Young Gen:

- part of the heap reserved for the allocation of new objects.

- It is divided into three parts – Eden Memory and two Survivor Memory spaces.

- When the Young space becomes full, garbage is collected by running a special young collection, where all the objects that have lived long enough in the Young gen are moved to the old space, thus freeing up the young space for more object allocation. This garbage collection is called Minor GC.

Important points about the Young gen:

  • Most of the newly created objects are located in the Eden Memory space
  • When Eden space is filled with objects, Minor GC is performed and all the survivor objects are moved to one of the survivor spaces
  • Minor GC also checks the survivor objects and moves them to the other survivor space. So at a time, one of the survivor space is always empty
  • Objects that have survived many cycles of GC, are moved to the old generation memory space. Usually, it is done by setting a threshold for the age of the nursery objects before they become eligible to promote to the old generation

2. Old Gen:

Usually, garbage collection is performed in Old generation memory when it’s full. Old generation garbage collection is called as Major GC and usually takes longer.


Perm Gen:

“Perm Gen” contains the application metadata required by the JVM to describe the classes and methods used in the application. 

Perm Gen also contains Java SE library classes and methods. Perm Gen objects are garbage collected in a full garbage collection.

Metaspace: 

With Java 8, there is no Perm Gen, which means there is no more “java.lang.OutOfMemoryError: PermGen” space problems. 

Unlike Perm Gen which resides in the Java heap, Metaspace is not part of the heap.


VM SwitchVM Switch Description
–XmsFor setting the initial heap size when JVM starts
-XmxFor setting the maximum heap size
-XmnFor setting the size of young generation, rest of the space goes for old generation
-XX:PermGenFor setting the initial size of the Permanent Generation Memory
-XX:MaxPermGenFor setting the maximum size of Perm Gen
-XX:SurvivorRatioFor providing ratio of Eden space, for example, if young generation size is 10m and VM switch is –XX:SurvivorRatio=2 then 5m will be reserved for Eden space and 2.5m each for both the Survivor spaces. The default value is 8
-XX:NewRatioFor providing ratio of old/new generation sizes. The default value is 2

Difference between PermGen Space and MetaSpace.

S.NoKeyPermGenMetaSpace
1
Basic
PermGen is the memory area for storing class data like static variable,byte code and etc
In Java 8, PermGen method area replaced with MetaSpace
2
Default Memory Allocation
By default 64 Mb is allocated for PermGen
It can by default auto increases its size
3
Tuned-up Memory Flag
It can be tuned by using -XXMaxPermSize.
We can restrict upper bound of the memory by -XX:MaxMetaspaceSize
4
Memory Area
It is a special Heap space.
Since Java 8, It is now separate memory area  in the native OS

Monitoring of Memory Use and GC Activity:

  • Utilization of the different memory pools (Eden, Survivor and old generation). Memory shortage is the number-one reason for increased GC activity.
  • If overall memory utilization is increasing continuously despite garbage collection, there is a memory leak, which will inevitably lead to an out-of-memory. In this case, a memory heap analysis is necessary
  • The number of young generation collections provides information on the churn rate (the rate of object allocations). The higher the number, the more objects are allocated. A high number of young collections can be the cause of a response-time problem and of a growing old generation (because the young generation cannot cope with the quantity of objects anymore)
  • If the utilization of the old generation fluctuates greatly without rising after GC, then objects are being copied unnecessarily from the young generation to the old generation. There are three possible reasons for this: the young generation is too small, there is high churn rate or there is too much transactional memory usage

jstat

The jstat utility uses the built-in instrumentation in the Java HotSpot VM to provide information about the performance and resource consumption of running applications. The tool can be used when diagnosing performance issues and in particular, issues related to heap sizing and garbage collection. 

The jstat utility does not require the VM to be started with any special options. The built-in instrumentation in the Java HotSpot VM is enabled by default. This utility is included in the JDK download for all operating systems. The jstat utility uses the virtual machine identifier (VMID) to identify the target process.

Using jstat command with gc option to find out the JVM Heap Memory usage.

<JAVA_HOME>/bin/jstat –gc <JAVA_PID>


S0CCurrent survivor space 0 capacity (KB)
S1CCurrent survivor space 1 capacity (KB)
S0USurvivor space 0 utilization (KB)
S1USurvivor space 1 utilization (KB)
ECCurrent eden space capacity (KB)
EUEden space utilization (KB)
OCCurrent old space capacity (KB)
OUOld space utilization (KB)
MCMetasapce capacity (KB)
MUMetaspace utilization (KB)
CCSCCompressed class space capacity (KB)
CCSUCompressed class space used (KB)
YGCNumber of young generation garbage collection events
YGCTYoung generation garbage collection time
FGCNumber of full GC events
FGCTFull garbage collection time
GCTTotal garbage collection time



Comments

Post a Comment

Popular posts from this blog

Java Design Patterns

Image
D esign patterns are programming language independent strategies for solving the common object-oriented design problems. That means a design pattern represents an idea, not a particular implementation. By using the design patterns you can make your code more flexible, reusable, and maintainable. It is the most important part because java internally follows design patterns. Categorization of design patterns: Basically, design patterns are categorized into two parts: Core Java (or JSE) Design Patterns. JEE Design Patterns. Core Java Design Patterns In core java, there are mainly three types of design patterns, which are further divided into their sub-parts: 1.Creational Design Pattern Factory Pattern Abstract Factory Pattern Singleton Pattern Prototype Pattern Builder Pattern. 2. Structural Design Pattern Adapter Pattern Bridge Pattern Composite Pattern Decorator Pattern Facade Pattern Flyweight Pattern Proxy Pattern 3. Behavioral Design Pattern Chain Of Responsibility Pattern Command Pa...
Read more

Java 8 Concepts with Examples

Java 8 new features  1. Lambda Expressions A lambda expression is an anonymous function. A function that doesn’t have a name and doesn’t belong to any class.   so compiler does not create .class file. Used to provide the implementation of an interface which has functional interface      //Syntax of lambda expression ( parameter_list ) -> { function_body }      Example: Creating Thread with Lambda  package com.vasanth.java8; public class ThreadWithLambda { public static void main (String args[]){ //Traditional approach Runnable r1= new Runnable() { @Override public void run() { System. out .println( "Thread 1 started" ); } }; Thread t1= new Thread(r1); t1.start();                                        //With Lambda Runnabl...
Read more