Performance

A comprehensive analysis of JFR (Java Flight Recorder) configuration system, usage methods, and event collection mechanisms. Covers JFR configuration system (global configuration, recording level configuration, JFC configuration files), multiple usage methods (JVM parameters, jcmd commands, JDK API, JMX), jfr tool analysis, event type classification and configuration applicability, as well as core changes and best practices from JDK 11 to JDK 25.

A comprehensive guide exploring why enabling HeapDumpOnOutOfMemoryError can cause significant performance issues in production environments, which OutOfMemoryError types actually trigger heap dumps, and better alternatives like JFR for memory leak detection and automatic service restart strategies.

A comprehensive comparison of PostgreSQL and MySQL for OLTP scenarios, exploring their fundamental architectural differences in secondary index handling and MVCC implementation, with practical insights on when to choose each database.

Discover when GraalVM Native Image processes show up in jps and learn our battle-tested approach for choosing between GraalVM Native Image and JVM in production environments. We break down our strategy for Lambda-style tasks versus long-running microservices.

Learn how to develop and test high-performance API clients using WebClient, TestContainers, and toxicproxy. This comprehensive guide covers asynchronous request handling, isolated testing environments, and realistic failure simulation for robust microservice development.

A comprehensive deep-dive into JVM memory architecture covering heap memory, metaspace, thread stacks, and compressed object pointers. This technical analysis examines memory allocation processes, Native Memory Tracking, and provides practical examples using tools like jol, jhsdb, and JFR for understanding JVM memory management internals.

A deep dive into diagnosing and resolving a production JVM issue where applications would freeze during hourly log synchronization tasks. We explore safepoint analysis, JVM log output blocking, asynchronous logging implementation, and WebFlux optimization to achieve a complete solution.

An in-depth investigation into mysterious JVM safepoint delays after upgrading to Java 17 and implementing centralized log collection with AWS EFS. We discovered how file I/O blocking during log output can freeze entire JVM processes and solved it using async logging and proper WebFlux implementation.

A comprehensive guide to understanding why MySQL queries slow down over time in sharded environments, exploring the underlying causes of storage fragmentation and MVCC-related issues, and providing practical solutions using table rebuilding techniques with OPTIMIZE TABLE for maintaining optimal database performance.

A deep dive into Java Memory Model (JMM) from specification to implementation, covering memory barriers, CPU reordering, and Java 9+ VarHandle APIs. Learn about coherence, causality, consensus, and how volatile, final, and other synchronization mechanisms work under the hood with practical jcstress examples.

Discover how enabling code location in logs can cause severe CPU performance issues in microservices, especially reactive applications. This deep-dive analysis reveals the hidden costs of stack walking in Log4j2 and provides actionable solutions for high-throughput systems.

A deep dive into MySQL’s InnoDB optimizer statistics and how sampling inaccuracies can lead to poor index selection, causing dramatic performance differences between similar queries. Learn practical solutions to prevent slow SQL queries caused by optimizer misjudgments.

A comprehensive guide on how to properly configure Spring Data Redis with Lettuce to enable pipeline functionality. Learn about connection sharing, AutoFlushCommands, and PipeliningFlushPolicy configurations to optimize your Redis batch operations and reduce network round-trip time.

A production incident investigation revealing how Spring Data Redis + Lettuce can leak connections when mixing SessionCallback and executeWithStickyConnection operations. Deep dive into connection management mechanisms, JFR analysis techniques, and practical solutions to prevent your Redis connection pool from becoming a black hole.

A deep dive into a production incident where our Spring Cloud Gateway experienced cascading failures due to blocking Redis operations. Learn how synchronous API calls in reactive environments can cause thread starvation, leading to health check failures and system-wide avalanches, plus the complete solution using async patterns.

When our operations team brought us a complex SQL query that was taking forever to execute, we thought it was just a performance issue. Little did we know, this investigation would uncover a deeply hidden character encoding mismatch that had been silently causing full table scans in our production database.

In-depth analysis of a microservice performance issue with CPU spikes and database connection anomalies. Through JFR profiling, we discovered the root cause was Java SecureRandom blocking on /dev/random and provide solutions using /dev/urandom.

A deep dive into JVM’s Thread Local Allocation Buffer (TLAB) mechanism, covering design principles, implementation details, performance optimization, and source code analysis. Learn how TLAB improves memory allocation efficiency in multi-threaded environments and master TLAB tuning techniques.

Discover how OpenJDK 11 revolutionized JVM logging with its unified configuration system. Learn about essential log tags for GC analysis, class loading, and runtime compilation, plus master dynamic log configuration using jcmd for real-time performance tuning.