by Karun Subramanian
on June 5, 2015
GC is supposed to save the developers from the tedious task of managing the memory (remember malloc and free and how accidentally you can free an object that is actually being referenced somewhere else and thereby causing unexpected errors ??). However, the very same GC can be a resource hog and bring your application to its knees.
What are the symptoms of Excessive Garbage Collection ?
1. No apparent errors in the logs files but the application is extremely slow
2. Restarting application seems to provide relieve for short period but the slowness comes back eventually
What are the causes of excessive garbage collection ?
Read More
by Karun Subramanian
on May 30, 2015
If there is one memory related issue that strikes you off guard, that must be ‘running out of permgen space’. Fortunately it is easy to fix.
What are the symptoms of running out of Permgen space ?
1. Unexpected application errors
2. Unable to start the application
3. java.lang.OutOfMemoryError:PermGen space in the log file.
What causes to run out of Permgen space ?
Permgen is a an area of Heap that stores class objects and interned strings. You don’t have to get into the details but know that permgen area will fill up if you load tons of classes, which will be the case if you load numerous third party libraries. Specifically, some of the ‘javaagent’ libraries (an important component in APM tools) are known to demand large permgen space.
The default permgen size (this varies by version and platform, typically 64MB) may not be enough in some cases especially if you use several third party libraries as mentioned above.
How to prevent Heap ‘running out of Permgen space’ ?
1. Try pumping up the permgen space to 256MB or more if you need
-XX:MaxPermSize=256m
2. Ensure that you are NOT loading tons of third party libraries that you don’t need. Check the classpath, java library path and startup logs to see if you find any clue.
3. Upgrade to Java 1.8. Note that there is NO permgen in java 1.8 onward. It has been replaced by Metaspace. But note that this may not be cure-all. Check out my other post: One important change in Memory Management in Java 8
Moving on, you may not see any error at all in your log files but your application could be extremely slow due to this lethal Heap related issue – Excessive garbage collection.
Coming up: Troubleshooting GC: Excessive garbage collection
Previous: Troubleshooting GC: Heap Fragmentation
by Karun Subramanian
on May 30, 2015
OutOfMemory error can occur due to fragmented heap. This issue is not as common as the heap exhaustion but it is a deadly issue regardless.
What are the symptoms of Heap Fragmentation ?
1. Java.lang.OutOfMemory errors in the Application log file
2. Application is not responsive or extremely slow
3. Unexpected errors in user experience
What causes Heap Fragmentation ?
Read More
by Karun Subramanian
on May 30, 2015
When your application has used up the entire allocated heap (-Xmx) and still needs more, you run into the classic OutOfMemory error. There is simply no more memory available for your application.
What are the symptoms for Heap Exhaustion?
1. Application is not responsive or extremely slow
2. Java.lang.OutOfMemory error in the Application log file
3. Possible Heap Dump file if the Application Server that is running your application is configured to do so
What causes Heap Exhaustion?
Read More
by Karun Subramanian
on May 25, 2015
GC algorithms/collectors define how GC is expected to behave at run time. There are various Collectors that you can use depending on your need. Note that the collectors vary greatly by the implementation of the JVM. This document addresses Oracle Hotspot JVM.
Note: Unless you explicitly specify a GC collector in the JVM command line, JVM selects the best collector to use based on various factors such as the hardware, platform etc
1. Serial Collector
Simplest. It uses just one thread to perform the GC operation. So, it is suited for single processor machines (are there any still left ?).
Read More
by Karun Subramanian
on May 24, 2015
Generational heap:
The heap space is primarily divided into two segments as follows:
1. Nursery or Young generation (or Eden)
2. Old or Tenured generation
(There are other segments, and they vary by the JVM vendor. But for the most part understanding the above two segments is enough to troubleshoot GC issues)
As your application runs, the new objects are created in young generation. When the young generation is about to fill up, GC runs what is known as a ‘minor‘ collection and reclaims memory from unused objects in young generation. While at it, the minor collection also moves ‘long lived’ objects to ‘old’ generation. A ‘major‘ collection (a.k.a Full GC), which is invoked when there is serious unmet demand for memory, sweeps through the entire heap to reclaim memory.
Read More
by Karun Subramanian
on May 24, 2015
It stinks when you don’t throw away of the Garbage
Every java application, whether it is an one line ‘hello world’ application, or an online banking application with millions of users, needs Physical memory to run. And this memory has an upper limit (sorry, you can’t have the cake and eat it too) which is defined by the parameter –Xmx in the Java command line that starts the application.
Example:
Java –Xmx128m HelloWorld
In the above command, 128M is the maximum memory the HelloWorld application can have. This memory is called Heap and it lives in the memory available in the host operating system. As your program executes, it creates Objects, which occupy memory. JVM allocates this memory using available heap.
Read More
by Karun Subramanian
on May 24, 2015
Software needs memory (RAM) to run. Unfortunately memory is limited. This simply means this: Your application must manage the memory usage effectively or it will suffer.
In a Java application, much of the memory management – scratch that – all of memory management is handled by JVM itself. This is great news for the developers as they don’t need to meddle with ‘malloc’,’free’ and the like. However, due to the fact that every application is different, the out- of-the box JVM memory management may not be efficient.
Garbage Collector is the key element in JVM memory management. In order for your application to run at its maximum speed and reliability, Garbage Collector a.k.a GC must be tuned. GC tuning can be a very time consuming process, mainly because,
1. There are plethora of GC tuning options
2. It takes rigorous testing to identify the effectiveness of the tuning
In the following segments, I will explain how Garbage collector works, the various memory related issues that you might face and how to troubleshoot them. I will also show you few handy tools you can use to speed up troubleshooting.
Coming up: Troubleshooting GC: What is GC and how it works – Part 1
by Karun Subramanian
on May 15, 2015
Garbage Collection is a life saver. Sure, you don’t have to mess with malloc() and free() and not worry about accidently deallocating objects that are still being referenced. But is GC a cure-all? Does it save you from all memory issues? Worse yet, can it cause more damage than good? Here are three reasons why GC is overrated:
Read More
by Karun Subramanian
on March 20, 2015
Application monitoring is vital for any organization. But implementing and maintaining a reliable Application monitoring system can be a very complex process, primarily because of the number of various metrics that can be monitored. In this article, I would like to take you back to the basics, and explain two chief metrics that you must monitor no matter what your application is or does.
Read More