Amazon

Thursday, May 11, 2017

Garbage Collection in Java in easy language

What is Throughput in gc(garbage collection) in java ?
·         In short, Throughput is the time not spent in garbage collection (GC) ( in percent).
·         Throughput focuses on maximizing the amount of work by an application in a specific period of time. Examples of how throughput might be measured include >
o    The number of transactions completed in a given time.
o    The number of jobs that a batch program can complete in an hour.
o    The number of database queries that can be completed in an hour.

What are pauses in gc(garbage collection) in java ?
·         Pauses is applications pauses i.e. when application doesn’t gives any response because of garbage collection (GC).

JVM Heap memory (Hotspot heap structure) with diagram in java:



JVM Heap memory (Hotspot heap structure)  in java consists of following elements>
1)     Young Generation
i)      Eden,
ii)     S0 (Survivor space 0)
iii)    S1 (Survivor space 1)
2)     Old Generation (Tenured)
3)     Permanent Generation.
So, JVM Heap memory (Hotspot heap structure) is divided into three parts Young Generation, Old Generation (tenured) and Permanent Generation.

Young Generation is further divided into Eden, S0 (Survivor space 0) and S1 (Survivor space 1).



GARBAGE COLLECTION (Minor and major garbage collection) in JVM Heap memory (i.e. in young, old and permanent generation)
3.1) Young Generation (Minor garbage collection occurs in Young Generation)
·         New objects are allocated in Young generation.
·         Minor garbage collection occurs in Young Generation.

When minor garbage collection?
·         When the young generation fills up, this causes a minor garbage collection.
·         All the unreferenced (dead) objects are cleaned up from young generation.

When objects are moved from young to old generation in JVM heap?
·         Some of the objects which aren't cleaned up survive in young generation and gets aged.  Eventually such objects are moved from young to old generation.

What is Stop the World Event?
·         Minor garbage collections are called Stop the World events.
·         All the non-daemon threads running in application are stopped during minor garbage collections (i.e. the application stops for while).
·         Daemon threads performs minor garbage collection. (Daemon threads are low priority threads which runs intermittently in background for doing garbage collection).

Division of Young Generation
a) Eden            b) S0 (Survivor space 0)           c) S1 (Survivor space 1)

3.2) Old Generation or (tenured generation) - (Major garbage collection occurs in Old Generation)
·         The Old Generation is used for storing the long surviving aged objects (Some of the objects which aren't cleaned up survive in young generation and gets aged.  Eventually such objects are moved from young to old generation).
·         Major garbage collection occurs in Old Generation.

At what time (or what age) objects are moved from young to old generation in JVM heap?
·         There is some threshold set for young generation object and when that age is met, the object gets moved to the old generation during gc(garbage collection) in java.

What is major garbage collection in java?
·         When the old generation fills up, this causes a major garbage collection. Objects are cleaned up from old generation.
·         Major collection is much slower than minor garbage collection in jvm heap because it involves all live objects.

Major garbage collection are Stop the World Event in java?
·         Major garbage collections are also called Stop the World events.
·         All the non-daemon threads running in application are stopped during major garbage collections.
·         Daemon threads performs major garbage collection.

Major gc(garbage collections) in responsive applications in java?
·         Major garbage collections should be minimized for responsive applications because applications must not be stopped for long.

Optimizing Major gc(garbage collections) in responsive applications in java?
Selection of appropriate garbage collector for the old generation space affects the length of the “Stop the World” event for a major garbage collection.


3.3) Permanent Generation or (Permgen) - (full garbage collection occurs in permanent generation in java).
·         Permanent generation Space contains metadata required by JVM to describe the classes and methods used in the application.
·         The permanent generation is included in a full garbage collection in java.
·         The permanent generation space is populated at runtime by JVM based on classes in use in the application.
·         The permanent generation space also contains Java SE library classes and methods in java.
·         JVM garbage collects those classes when classes are no longer required and space may be needed for other classes in java.

Configuring VM (JVM) PARAMETERS in JVM Heap memory
Total Heap Size Configuration
Providing minimum heap size -Xms is minimum heap size which is allocated at initialization of JVM.

Example1 Set the minimum heap size of JVM to 512 megabytes.
java -Xms512m MyJavaProgram

Example2 Set the minimum heap size of JVM to 1 gigabyte.
java -Xms1g MyJavaProgram

Providing maximum heap size -Xmx is the maximum heap size that JVM can use.

Example1 Set the maximum heap size of JVM to 512 megabytes.
java -Xmx512m MyJavaProgram

Example2 Set the maximum heap size of JVM to 1 gigabyte.
java -Xmx1g MyJavaProgram

Young Generation(VM PARAMETERS for Young Generation)
a) Eden,
b) S0 (Survivor space 0)
c) S1 (Survivor space 1)

-Xmn : -Xmn sets the size of young generation.

Example1 - java -Xmn512m MyJavaProgram
Example2 - java -Xmn1g MyJavaProgram 

-XX:NewRatio : NewRatio controls the size of young generation.
Example-XX:NewRatio=3 means that the ratio between the young and old/tenured generation is 1:3.
In other words, the combined size of the eden and survivor spaces will be one fourth of the total heap size.

-XX:NewSize - NewSize is minimum size of young generation which is allocated at initialization of JVM.
Note : If you have specified -XX:NewRatio than minimum size of the young generation is allocated automatically at initialization of JVM.

-XX:MaxNewSize - MaxNewSize is the maximum size of young generation that JVM can use.

-XX:SurvivorRatio :   (for survivor space)
SurvivorRatio can be used to tune the size of the survivor spaces, but this is often not as important for performance.
Example:  -XX:SurvivorRatio=6 sets the ratio between each survivor space and eden to be 1:6.
In other words, each survivor space will be one eighth of the young generation (not one seventh, because there are two survivor spaces).

Old Generation (tenured) - (VM PARAMETERS for Old Generation)

-XX:NewRatio : NewRatio controls the size of young and old generation.
Example of using -XX:NewRatio: -XX:NewRatio=3 means that the ratio between the young and old/tenured generation is 1:3. In other words, the combined size of the eden and survivor spaces will be one fourth of the total heap size.

Permanent Generation (VM PARAMETERS for Permanent Generation)

-XX:PermSize: It’s is initial value of Permanent Space which is allocated at startup of JVM.

Example1 : Set initial value of Permanent Space as 512 megabytes to JVM
java -XX:PermSize=512m MyJavaProgram

Example2 : Set initial value of Permanent Space as 512 gigabyte to JVM
java -XX:PermSize=1g MyJavaProgram

-XX:MaxPermSize: It’s maximum value of Permanent Space that JVM can allot up to.

Example1 : set maximum value of Permanent Space as 512 megabytes to JVM
java -XX:MaxPermSize=512m MyJavaProgram

Example2 : set maximum value of Permanent Space as 1 gigabyte to JVM
java -XX:MaxPermSize=1g MyJavaProgram

Other important VM (JVM) parameters for java heap in java

-XX:MinHeapFreeRatio and -XX:MaxHeapFreeRatio
JVM can grows or shrinks the heap to keep the proportion of free space to live objects within a specific range.

-XX:+AggressiveHeap is used for Garbage Collection Tuning setting.
This VM option inspects the server resources and attempts to set various parameters in optimal manner for long running and memory consuming applications. There must be minimum of 256MB of physical memory on the servers before the AggressiveHeap can be used.

-Xss - Use this VM option to adjust the maximum thread stack size.

Also you must know that -Xss option is same as -XX:ThreadStackSize.

Example1 : set the default stack size of JVM  to 512 megabytes.
java -Xss512m MyJavaProgram

Example2 : set the default stack size of JVM  to 1 gigabyte.
java -Xss1g MyJavaProgram


Different types Garbage collectors

Serial collector / Serial GC (Garbage collector) in java
·         Serial collector is also called Serial GC (Garbage collector) or Serial Collector in java.
·         Serial GC (Garbage collector) is rarely used in java.
·         Serial GC (Garbage collector) is designed for the single threaded environments in java.
·         In Serial GC (Garbage collector) , both minor and major garbage collections are done serially by one thread (using a single virtual CPU) in java.
·         Serial GC (Garbage collector) uses a mark-compact collection method. This method moves older memory to the beginning of the heap so that new memory allocations are made into a single continuous chunk of memory at the end of the heap. This compacting of memory makes it faster to allocate new chunks of memory to the heap in java.
·         The serial garbage collector is the default for client style machines in Java SE 5 and 6.

When to Use the Serial GC (garbage Collector) in java?
·         The Serial GC is the garbage collector of choice for most applications that do not have low pause time requirements and run on client-style machines. It takes advantage of only a single virtual processor for garbage collection work in java.
·         Serial GC (garbage collector) is also popular in environments where a high number of JVMs are run on the same machine. In such environments when a JVM does a garbage collection it is better to use only one processor to minimize the interference on the remaining JVMs in java.

Vm (JVM) option for enabling serial GC (garbage Collector) in java
-XX:+UseSerialGC
Example of Passing Serial GC in Command Line for starting jar
java -Xms256m -Xms512m  -XX:+UseSerialGC -jar d:\MyJar.jar

Throughput GC (Garbage collector) or Parallel collector in java
·         Throughput collector is also called
o    Throughput GC (garbage collector)
o    ParallelGC (garbage collector)
o    Throughput collector
o    ParallelGC collector
·         Throughput garbage collector is the default garbage collector for JVM in java.
·         Throughput garbage collector uses multiple threads to execute a minor collection and so reduces the serial execution time of the application in java.
·         The throughput garbage collector is similar to the serial garbage collector but uses multiple threads to do the minor collection in java.
·         This garbage collector uses a parallel version of the young generation garbage collector in java.
·         The tenured generation collector is the same as the serial garbage collector in java.

When to Use the Throughput GC (Garbage collector) in java?
·         The Throughput garbage collector should be used when application can afford low pauses in java.
·         And application is running on host with multiple CPU’s (to derive advantage of using multiple threads for garbage collection) in java.

Vm (JVM) option for enabling throughput GC (Garbage collector) in java
            -XX:+UseParallelGC

Example of using throughput collector in Command Line for starting jar
java -Xms256m -Xms512m  -XX:+UseParallelGC -jar d:\MyJar.jar

With this Vm (JVM) option you get a
·         Multi-threaded young generation garbage collector in java,
·         single-threaded old generation garbage collector in java and
·         single-threaded compaction of old generation in java.

Vm (JVM) option for enabling throughput collector with n number of threads in java
·         -XX:ParallelGCThreads=

Another Vm (JVM) option for enabling throughput collector in java
·         -XX:+UseParallelOldGC

Goals for Throughput GC (Garbage collector) in java
·         Maximum pause time goal (Highest priority)
·         Throughput goal
·         Minimum footprint goal (Lowest priority)

Controlling maximum pause time and throughput
Maximum pause time goal (Highest priority)
·         Vm (JVM) option for maximum pause time in java.
o    We gives hint to throughput collector that pause time should be milliseconds or less.
o    -XX:MaxGCPauseMillis=
o    Example. We gives hint to throughput collector that pause time should be 100 milliseconds or less.     -XX:MaxGCPauseMillis=100
·         The throughput collector will adjust the Java heap size and other garbage collection related parameters in an attempt to keep garbage collection pauses shorter than milliseconds.
·         By default there is no maximum pause time goal.

Throughput goal
·         Vm (JVM) option for throughput in java.
·         The throughput is measured time spent doing garbage collection and time spent outside of garbage collection. -XX:GCTimeRatio=
·         Example : XX:GCTimeRatio=19 sets a goal of 5% of the total time for garbage collection. By default the goal for total time for garbage collection is 1%.
·         The ratio of garbage collection time to application time is 1 / (1 + )

Performance of Throughput GC (garbage Collector) host with different number of CPU’s in java
·         By default on a host with N CPUs, the throughput collector uses N garbage collector threads in the minor collection. Note : We can control  number of garbage collector threads with a command line option in java.
·         On a host with 1 CPU the throughput collector will not perform as well as the serial collector because of the additional overhead for the parallel execution (Example - Synchronization costs) in java.
·         On a host with 2 CPUs the throughput collector generally performs as well as the serial garbage collector and a reduction in the minor garbage collector pause times can be expected on hosts with more than 2 CPUs in java.

Adjusting Generation Sizes in throughput GC (Garbage collector)
·         By default a generation
o    grows in increments of 20% and
o    shrinks in increments of 5%.
·         Controlling growth of generation (in percent) >
o    -XX:YoungGenerationSizeIncrement= for the young generation and
o    -XX:TenuredGenerationSizeIncrement= for the tenured generation.
·         shrink of generation (in percent) >
o    -XX: AdaptiveSizeDecrementScaleFactor=
o    If the size of an increment for growing is growthPercent, the size of the decrement for shrinking will be growthPercent/ shrinkPercent.

5.4) Concurrent Mark Sweep (CMS) Collector / concurrent low pause collector in java
·         Concurrent Mark Sweep Collector is also called
o    concurrent low pause collector
o    concurrent low pause GC (garbage collector)
o    CMS GC (garbage Collector)
o    CMS Collector
o    concurrent low pause collector
o    concurrent low pause GC (garbage collector)
·         Concurrent Mark Sweep (CMS) collector collects the old/tenured generation in java.
·         Concurrent Mark Sweep (CMS) Collector minimize the pauses by doing most of the garbage collection work concurrently with the application threads in java.
·         Concurrent Mark Sweep (CMS) Collector action on live objects >
o    Concurrent Mark Sweep (CMS) Collector does not copy or compact the live objects. A garbage collection is done without moving the live objects. If fragmentation becomes a problem, allocate a larger heap in java.

When to Use the Concurrent Low Pause Collector in java
·         Concurrent Low Pause Collector should be used if your applications that require low garbage collection pause times in java.
·         Concurrent Low Pause Collector should be used when your application can afford to share processor resources with the garbage collector while the application is running in java.
·         Concurrent Low Pause Collector is beneficial to applications which have a relatively large set of long-lived data (a large tenured generation) and run on machines with two or more processors in java.
·         Examples when to use  Concurrent Mark Sweep (CMS) collector / concurrent low pause collector
Example 1 - Desktop UI application that respond to events,
Example 2 - Web server responding to a request and
Example 3 - Database responding to queries.

Vm (JVM) option for enabling Concurrent Mark Sweep (CMS) Collector
·         -XX:+UseConcMarkSweepGC

Example of using Concurrent Mark Sweep (CMS) collector / concurrent low pause collector
java -Xms256m -Xms512m  -XX:+UseConcMarkSweepGC -jar d:\MyJar.jar

Concurrent Mark Sweep (CMS) Collector / concurrent low pause collector working in detail
As mentioned above Concurrent Mark Sweep (CMS) collector collects the old/tenured generation (i.e. performs Major garbage collection process).

Major gc(garbage collection) in Concurrent Mark Sweep (CMS) Collector / concurrent low pause
·         For each major collection the CMS collector will pause all the application threads for a brief period at the beginning of the collection and toward the middle of the collection.
·         The second pause tends to be the longer than first pause and uses multiple threads to do the collection work during that pause in java. The remainder of the collection is done with a garbage collector thread that runs concurrently with the application.

Minor gc (garbage collection) in Concurrent Mark Sweep (CMS) Collector / concurrent low pause collector
·         The minor collections is done in a manner similar to the serial collector although multiple threads are used to do the collection in java.

Heap Structure for CMS garbage Collector
·         CMS garbage collectors didies heap into three sections: young generation, old generation, and permanent generation of a fixed memory size.
·         Young Generation is further divided into Eden, S0 (Survivor space 0) and S1 (Survivor space 1).

Detailed Steps in GC (garbage collection) cycle in Concurrent Mark Sweep (CMS) Collector / concurrent low pause garbage collector:
·         Young Generation GC (garbage Collection)
o    Live objects are copied from the Eden space and survivor space to the other survivor space.
o    Any older objects that have reached their aging threshold are promoted to old generation.
·         After Young generation GC (garbage Collection) in java
o    After a young GC, the Eden space and one of the survivor spaces is cleared. Eden, S0 and S1 are part of Young Generation
o    promoted objects (older objects that have reached their aging threshold in young GC) are are available in old generation.
  • Old Generation GC (garbage Collection) with CMS in java
    1. Initial mark phase - (First pause happens/ stop the world event ) - mark live/reachable objects (Example - objects on thread stack, static objects etc.) and elsewhere in the heap (Example - the young generation).
    2. Concurrent marking phase - (No pause phase ) -  finds live objects while the application continues to execute.
0.                 Remark - (Second pause happens/ stop the world events) - It finds objects that were missed during the concurrent marking phase due to the concurrent execution of the application threads.
Old Generation GC (garbage Collection) - Sweep phase (Concurrent Sweep phase) in java
1.    Sweep phase -  do the concurrent sweep, memory is freed up.
·         Objects that were not marked in the previous phase are deallocated in place.
·         There is no compaction
·         Unmarked objects are equal to Dead Objects.
·         Old Generation GC (garbage Collection) - After Sweeping
5.     Reset phase - do the concurrent reset.




No comments:

Post a Comment

Amazon Best Sellors

Weblogic - Server Creation - Issues

Datasource creation using python script.  Python Script was failing after creating Datasource. From UI Admin Console, if I try to activat...