Tagged articles
jstack
43 articles · Page 1 of 1
This article details systematic troubleshooting for 900% CPU spikes in MySQL and Java processes, covering top/jstack diagnostics, show processlist analysis, index optimization, cache integration, and fixing busy-wait loops with BlockingQueue.take(), illustrated through real production case studies.
Java thread analysisMySQL performance tuningblocking queue
0 likes · 12 min read


liandkSep 14, 2026 · Backend Development
This guide covers real-world diagnosis and resolution of Java thread deadlocks and thread pool exhaustion — the two most common causes of service hangs with zero errors — using jstack, Arthas, and thread-state analysis to pinpoint root causes and apply permanent fixes.
ArthasJavajstack
0 likes · 13 min read


liandkSep 13, 2026 · Backend Development
This article provides a comprehensive guide to troubleshooting Java CPU 100% spikes in production, covering root cause categories, a standard SOP using top, jstack, and thread analysis, a real-world infinite loop case study, GC-related CPU issues, emergency mitigation steps, and long-term prevention practices.
JavaPerformance TuningRoot Cause Analysis
0 likes · 13 min read

This article explains how deadlocks arise from four necessary conditions, shows how to detect them with jstack, outlines practical ways to prevent deadlock, distinguishes livelock and starvation, and presents three prioritized approaches—immutability, thread confinement, and synchronization—to achieve thread safety in Java.
ConcurrencyImmutableJava
0 likes · 16 min read

When a Java application suddenly hits 100% CPU and becomes unresponsive, this guide walks through a three-step investigation—identifying the hottest process, the most CPU-intensive thread, and the offending code—using tools like top, jstack, and Arthas, and presents common causes and preventive measures.
ArthasCPUJava
0 likes · 6 min read

This guide explains how to troubleshoot common online Java problems—including high CPU, OutOfMemoryError, disk I/O, and network latency—by using tools such as top, jps, jstack, jmap, MAT, df, and ping to pinpoint root causes like infinite loops, memory leaks, lock contention, and resource exhaustion.
CPUJavaMAT
0 likes · 8 min read

This article explains what a deadlock is, the four necessary conditions that cause it, demonstrates classic synchronized‑based and Lock‑based deadlock examples in Java, shows how to detect deadlocks with tools such as Arthas, jstack, jvisualvm and JMC, and provides practical strategies—including lock ordering, timeout locks, and two‑phase locking—to break each condition and avoid deadlocks in production code.
ArthasConcurrencyJava
0 likes · 24 min read


ITPUBJun 24, 2025 · Backend Development
This guide explains why Java applications can hit 100% CPU in production, introduces the two primary diagnostic tools jstack and Arthas, and provides step‑by‑step commands and code examples to locate the exact source line responsible for the CPU spike.
ArthasCPU profilingJava
0 likes · 13 min read

This guide explains how to locate the cause of sudden CPU spikes in a Java program by using the top command to identify the offending process and thread, converting the thread ID to hexadecimal, and analyzing stack traces with jstack to pinpoint the problematic code line.
BackendCPU profilingJava
0 likes · 4 min read

This article explains what a Java thread dump is, describes multiple ways to generate it—including JDK command‑line tools like jstack and jcmd, OS signals such as kill ‑3, and programmatic access via ThreadMXBean—provides syntax, options, examples, and recommendations for choosing the appropriate method.
JavaThreadMXBeandiagnostics
0 likes · 9 min read

This article walks through a real‑world Java CPU‑usage issue, showing how top, thread ID conversion, and jstack were used to pinpoint a faulty loop in LoguUtil, then verifies the fix restores normal CPU consumption while emphasizing the importance of performance testing.
BackendCPUJava
0 likes · 4 min read

This guide walks through real‑world scenarios of high CPU and memory alerts, demonstrating how to use Linux's top tool, interpret its detailed output, convert thread IDs, and leverage jstack dumps to pinpoint and resolve performance bottlenecks.
CPUMemoryPerformance Monitoring
0 likes · 5 min read

This article explains a three‑step method—using top to locate the CPU‑hungry Java process, identifying the offending thread, and printing its stack with jstack—to pinpoint and resolve excessive CPU consumption in a Java application running on Linux.
CPUJavaLinux
0 likes · 4 min read

This guide explains how to use JDK command-line utilities such as jps, jstat, jinfo, jmap, jhat, and jstack to monitor JVM processes, inspect memory usage, generate heap dumps, and diagnose performance issues, providing command syntax, options, and practical examples.
command-line-toolsjmapjps
0 likes · 8 min read

This article explains how to locate Java deadlocks by using command‑line tools such as jps and jstack, the ThreadMXBean API’s findDeadlockedThreads method, and online utilities like FastThread and JStack Review, while also offering guidance on preventing and fixing deadlocks in production.
ConcurrencyJavaThreadMXBean
0 likes · 4 min read

When a production container suddenly hit 90% CPU, the author traced the issue to abnormal JVM garbage‑collection activity, captured the problematic GC graphs, and used Linux tools, jstack, and code inspection to pinpoint a faulty Excel export loop that caused excessive GC and full‑GC cycles.
CPU spikeJVMKubernetes
0 likes · 8 min read

This article explains what a deadlock is, demonstrates a simple Java deadlock example with code, outlines the four necessary conditions, and introduces four practical tools—jstack, jconsole, jvisualvm, and jmc—for diagnosing and resolving deadlocks in Java applications.
ConcurrencyJConsoleJMC
0 likes · 9 min read

This article explains practical JVM tuning scenarios—including how to identify and resolve excessive CPU consumption, thread deadlocks, and memory leaks—by using Linux tools such as top, jstack, jps, jstat, and jmap, and by analyzing heap dumps with Eclipse MAT.
CPUJVMJava
0 likes · 15 min read

This article explains Java’s six thread states—NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, and TERMINATED—provides detailed descriptions, shows how to inspect thread states using jstack and online tools, and includes example thread dumps for practical analysis.
ConcurrencyJavaThread
0 likes · 6 min read

This article introduces flame graphs, explains their visual characteristics and how they help identify performance bottlenecks in Java applications, and provides practical guidance on generating them using Perl scripts and shell commands to process jstack and perf outputs.
flamegraphjstackperformance profiling
0 likes · 9 min read

This article demonstrates how to combine Linux top with -H -p options and jstack to correlate Java thread IDs with their logical names, explains the underlying JDK thread‑naming bug, and provides practical recommendations for performance debugging on different JDK versions.
JDKJavaLinux
0 likes · 6 min read

This article introduces core JVM performance and monitoring utilities—including jps, jstack, jmap, jhat, jstat, and hprof—explains their command syntax, demonstrates practical steps to locate high‑CPU threads, analyze heap dumps, and interpret GC statistics, and provides concrete code examples for Java developers.
JVMJavaPerformance Tuning
0 likes · 13 min read

The article recounts a weekend on‑call incident where a Java monitoring service suffered network packet loss and a severe memory leak, leading to massive timeouts, high CPU usage, and frequent GC, and explains how the problem was diagnosed and resolved using tools such as top, jstat, jstack, jmap, and MAT.
JVMJavaMemory Leak
0 likes · 9 min read

This article introduces the jps tool for listing Java processes, explains its common options and usage examples, then provides a detailed overview of jstack, including its purpose, command syntax, thread‑state definitions, sample outputs, and practical tips for detecting deadlocks, counting threads, and diagnosing high CPU usage in Java applications.
DebuggingJavaThread Dump
0 likes · 7 min read

This article explains how flame graphs visualize call‑stack frequency and duration, shows how to generate them from Java jstack dumps using Perl tools, and demonstrates how to interpret their widths and flat tops to pinpoint performance hot spots in production systems.
Flame GraphJavajstack
0 likes · 11 min read

This article explains the concept, features, and practical usage of flame graphs—including how to generate them from Java thread dumps with Perl scripts—to help developers visualize call‑stack frequencies and quickly identify performance bottlenecks in backend services.
Operationsflamegraphjstack
0 likes · 11 min read

The article walks through a real‑world Java production incident where CPU spiked to 100%, detailing systematic troubleshooting steps, heap analysis with MAT, and the discovery that repeatedly creating BouncyCastleProvider objects caused a memory leak that was fixed by refactoring the code.
BouncyCastleCPU usageMemory Leak
0 likes · 6 min read


ITPUBMar 22, 2021 · Operations
This guide explains how to systematically investigate Java application problems across CPU, disk, memory, and network layers using Linux utilities and Java tools such as jstack, jstat, jmap, iostat, vmstat, and network commands, providing concrete commands and analysis steps to pinpoint root causes.
jstackjstattroubleshooting
0 likes · 21 min read

This article introduces a collection of essential Java tools—including jstack, jmap, jhat, jstat, jdb, jcmd, jps, jinfo, javap, javac, jconsole, and jvisualvm—explaining their purposes, common commands, and how they help diagnose memory leaks, CPU spikes, thread issues, and overall JVM performance.
DebuggingJavajhat
0 likes · 7 min read

This article explains common JVM problems such as OutOfMemoryError, memory leaks, and thread deadlocks, then introduces core monitoring tools—jps, jstack, jmap/jhat, jstat, and hprof—detailing their syntax, options, and practical examples to help Java developers diagnose and tune production applications.
HprofJVMjmap
0 likes · 15 min read

This guide walks through systematic troubleshooting of Java runtime issues—including CPU spikes, frequent garbage collection, memory leaks, disk bottlenecks, and network anomalies—by using Linux tools such as top, jstack, jstat, iostat, vmstat, and netstat, with concrete command examples and analysis steps.
GCJavajstack
0 likes · 18 min read

This article explains Java thread lifecycle, compares OS generic thread states with Java’s six states, shows how to query thread state via getState(), and introduces debugging tools like jstack and Arthas, helping developers master state transitions and write robust concurrent code.
ArthasConcurrencyDebugging
0 likes · 12 min read

This guide introduces essential JVM performance monitoring tools—including jps, jstack, jmap, jhat, jstat, and hprof—explains their command syntax, demonstrates step‑by‑step usage with real‑world examples, and shows how to interpret their output to diagnose memory leaks, thread issues, GC behavior, and CPU hotspots.
HprofJVMPerformance Monitoring
0 likes · 14 min read

This article introduces the most common JVM performance problems in enterprise Java applications and provides a practical guide to using core monitoring and tuning tools such as jps, jstack, jmap, jstat and hprof, complete with command syntax, sample outputs and step‑by‑step troubleshooting examples.
JVMJavaMonitoring Tools
0 likes · 13 min read

This article walks Java developers through diagnosing and fixing common problems such as deadlocks and CPU usage spikes, explaining the underlying concepts, showing practical code examples, and demonstrating how to use tools like jps, jstack, JConsole, JVisualVM, and Arthas to pinpoint and prevent performance bottlenecks.
ArthasCPUJVisualVM
0 likes · 10 min read

This article walks through setting up a Vagrant‑based experiment that injects an intentional infinite loop into a simple Spring MVC service, then demonstrates step‑by‑step how to identify the offending process using top, examine JVM heap with jstat, and trace the problematic thread with jstack to resolve a CPU‑100% issue.
CPUJVMJava
0 likes · 4 min read

This guide walks you through a step‑by‑step process using Linux top, jstack, and hex conversion to pinpoint the exact Java thread causing CPU spikes, enabling effective service optimization and cost reduction without unnecessary scaling.
Java performanceLinux topcpu-troubleshooting
0 likes · 5 min read


ITPUBApr 23, 2018 · Operations
This guide walks through real‑world Linux performance troubleshooting, showing how to use top to pinpoint high‑CPU processes, convert thread IDs, capture multiple jstack thread dumps, and interpret key top metrics such as load average, task states, and memory usage.
jstackmonitoringthread-dump
0 likes · 7 min read

This article explains how to identify and resolve intermittent high CPU usage in Java/Tomcat services by analyzing thread stacks with jstack, examining GC behavior with Jstat, and using Jmap for memory inspection, providing step‑by‑step commands and practical tips for ops engineers.
CPUJavaTomcat
0 likes · 7 min read

Learn how to diagnose and resolve common Java performance issues such as OutOfMemoryError, thread deadlocks, and high CPU usage by using built‑in JVM tools—including jps, jstack, jmap, jhat, jstat, and hprof—through detailed command examples, output explanations, and practical profiling techniques.
JVMJavaMonitoring Tools
0 likes · 11 min read

This guide walks IT operations engineers through systematic Linux‑based techniques for pinpointing Java processes that consume excessive CPU or memory, using tools like top, ps, jstack and jmap, and provides concrete steps to analyze and remediate the underlying code.
CPUJavaLinux
0 likes · 10 min read

The article outlines practical techniques for debugging live Java systems, emphasizing comprehensive distributed logging, global exception handling, proactive JStack usage, BTrace tracing, and custom JVM agents to quickly identify and resolve production issues.
BTraceDebuggingJVM
0 likes · 7 min read

This guide walks through identifying a Java process that spikes CPU usage, locating the offending thread with Linux tools, extracting its stack trace, pinpointing the problematic code in a socket utility class, and outlining the steps to resolve the infinite‑loop issue.
CPUDebuggingJava
0 likes · 6 min read
