The Java Concurrent Mark & Sweep (CMS) algorithm provides low-latency garbage collection, effective for applications with dynamic memory needs. Although deprecated in JDK 9 and removed in JDK 14, it can still be utilized in earlier versions. This post discusses tuning techniques, advanced options, and performance analysis for optimal results.
The Dell Boomi Core servers experienced a performance outage in the early morning at 4 a.m. Below are the symptoms observed: Dell Boomi wasn’t responding to any incoming requests CPU consumption was skyrocketing to 100% Entire Dell Boomi cluster had to be recycled to recover from the unresponsiveness. In this post, we have shared the... Continue Reading →
In Java, the finalize method has been part of the language since its early days, offering a mechanism to perform cleanup activities before an object is garbage collected. However, using finalizers has come under scrutiny due to several performance-related concerns. As of Java 9, the finalize method has been deprecated, and its use is highly... Continue Reading →
In this article, we are going to compare the performance of Garbage Collection(GC) of OpenJDK and GraalVM. The GraalVM is a popular open source JVM implementation in Java with a capability to run applications as native images. Apart from that, it has got other functionalities such as fast loading time, compacted memory usages,etc. Let’s compare the... Continue Reading →
The Parallel garbage collector in JVM enhances processing by utilizing multiple threads, reducing GC pauses. It suits applications focusing on throughput, batch processing, or larger heap sizes. Configuration involves specific JVM arguments to fine-tune heap and generation sizes, manage GC pause times, and optimize performance, requiring continuous monitoring for best results.
Automatic garbage collection in programming languages like Golang, Java, and Python simplifies memory management but may lead to high CPU usage. This article discusses methods to measure CPU consumption caused by garbage collection, including GC log analysis, monitoring tools, and examining CPU usage by GC threads, enabling performance optimizations for applications.
Modern programming languages offer automatic garbage collection, which simplifies memory management but can lead to increased CPU consumption and higher cloud hosting costs. This article outlines five strategies for developers to mitigate these issues: analyzing GC logs, switching GC algorithms, minimizing object creation, adjusting heap size, and scaling instances. Each approach aims to optimize application performance and reduce resource expenses.
DevOpsCon, a global conference in Berlin, featured a talk by our architect on "16 Artifacts to Capture When Your Container Application Is in Trouble." The session focused on essential artifacts for troubleshooting container performance, alongside tools and techniques for analysis. Attendees rated the talk 5 for quality and speaker knowledge.
Developers once managed memory manually, leading to leaks. Java's 1995 introduction of automatic garbage collection shifted this responsibility to the JVM. GC throughput, measuring time spent on processing versus garbage collection, is crucial for performance. Optimizing this throughput requires addressing issues like memory leaks, tuning, and resource allocation for better application efficiency.
Coming soon
