A leading automobile manufacturer enhanced their middleware platform's response time by 49.46% through optimizing garbage collection with the GCeasy tool, reducing average response time from 1.88 seconds to 0.95 seconds. This adjustment, achieved without code modifications, also decreased transactions exceeding 25 seconds from 0.7% to 0.31%.
The post outlines the regions of JVM memory, focusing on the Metaspace, which contains class metadata. It offers five methods to inspect loaded classes: using verbose flags for versions 8 and 9+, invoking jcmd, a programmatic approach, and performing Heap Dump analysis. Each method is described for practical usage.
The java.lang.String#intern() method can significantly reduce memory usage by eliminating duplicate strings in Java applications. A comparison of two programs—one utilizing intern() and the other not—demonstrated that the intern() method reduced memory consumption from 1.08GB to 38.37MB at the cost of increased response time.
The intern() function in Java's String class optimizes memory usage by managing a pool of string objects in the JVM. When invoked, it checks for existing strings, reusing them if present to eliminate duplicates. While beneficial for memory efficiency, using intern() can negatively impact application response time compared to other methods like string deduplication.
Garbage Collection events predominantly occur in the Java application layer, termed 'User' time, where the Garbage Collector identifies and marks active objects and evicts unreferenced ones. 'Sys' time represents the time spent in the Operating System/Kernel for memory allocation, deallocation, and disk I/O activities. Overall 'CPU' time combines both 'User' and 'Sys' time.
The intern() function in Java's String class helps eliminate duplicate string objects, reducing memory usage by storing interned strings in the JVM's heap region. This post includes practical examples, performance observations from a sample program, and highlights the significance of enabling garbage collection logging for memory management insights.
The post discusses troubleshooting a 'java.lang.OutOfMemoryError: Metaspace' issue in a microservice application, which works initially but fails after a few hours. It details identifying memory leaks in the Metaspace region through garbage collection logs and heap dump analysis, ultimately resolving the issue by upgrading a problematic third-party library.
This post compares the performance of HashMap, Hashtable, and ConcurrentHashMap through practical examples. It recommends ConcurrentHashMap for its thread-safe implementation, despite being marginally slower than HashMap. Testing showed HashMap performed best, but was not thread-safe, while Hashtable was significantly slower due to its synchronization constraints.
This post discusses the advantages of setting the initial heap size equal to the maximum heap size for Java applications running on JVM. It highlights benefits like improved application availability, enhanced performance, reduced startup time, and unchanged computing costs. The article argues that this practice is particularly beneficial for enterprise applications.