Jvm

Feeding JFR event streams to AI: an engineering path to centralized JVM monitoring and JMX self-healing—RecordingStream telemetry, LangChain4j multi-agent triage, and remote JMX actions with human-in-the-loop controls.

Post-Mortem JVM Crash Analysis: Read Cores with jcmd, Not a Second Toolchain

JVM and Spring Boot Observability: How the Three Signals Actually Connect

Hyperscale Java Platform: From Federated GraphQL to JVM Defaults

How generic code speeds up on the JVM: erasure, profiling, and climbing back after the performance cliff.

WebAssembly is not only compact bytecode in the spec—it is an execution model that pins guest modules to host boundaries. Running Wasm on the JVM forces trade-offs between attaching native runtimes versus pure bytecode hosting for distribution, observability, and fault isolation; Chicory, QuickJS4J, OPA Wasm, protobuf4j, Lumis4j, and related stacks illustrate one idea from many angles—wrapping existing C/Rust/JS assets in versioned artifacts exposed through Java APIs to Spring Gateway, build plugins, or CLIs.

In-depth guide on how to quickly locate Java heap OOM using JFR (JDK Flight Recorder) with practical methods and underlying principles, covering JFR event analysis for three typical OOM scenarios, including key events such as Allocation Requiring GC, ZAllocationStall, ObjectAllocationOutsideTLAB, and techniques for collecting and analyzing them.

An exploration of JEP 502’s StableValue API, which addresses the fundamental trade-off between immutability and initialization flexibility in Java. This article covers the API design, core implementation details including double-checked locking patterns, memory semantics, and JIT optimization strategies using the @Stable annotation.

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.

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.

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 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.

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.