Troubleshooting Java, Second Edition

by Laurentiu Spilca

Learn how to quickly work out what your Java code is doing so you can understand when and why it misbehaves.

Searching for bugs, detangling messy legacy code, or evaluating your codebase for new features sucks up much of a developer's time. Effectively reading and understanding existing code is a true superpower! Troubleshooting Java, Second Edition teaches you to efficiently analyze and debug Java applications using time-tested tools and new AI-powered techniques.

In Troubleshooting Java, Second Edition you’ll

• Efficiently use debuggers to quickly understand complex code
• Utilize AI-driven tools to automate log analysis, trace execution, and predict problems
• Correctly implement and interpret application logs
• Identify performance bottlenecks and optimize slow execution paths
• Profile SQL queries to diagnose and optimize database interactions
• Evaluate heap dumps to detect and fix memory leaks
• Analyze thread dumps to resolve deadlocks and concurrency issues
• Navigate the intricacies of service-oriented and microservices systems

In Troubleshooting Java, Second Edition Java veteran Laurentiu Spilca shares techniques for reading, profiling, debugging, and optimizing Java code that he’s honed over years working with high-stakes systems. This fully-revised second edition, updates coverage for new Java tools and adds methods for saving time and effort using AI. You’ll master techniques to identify memory leaks, optimize database queries, and resolve threading issues with ease. The code samples are in Java, but the skills you learn in this guide can be applied to any JVM language.

About the book

Troubleshooting Java, Second Edition introduces code investigation techniques that will help you efficiently understand how Java apps work, how to optimize them, and how to fix the bugs that break them. In it, you’ll learn timesaving practices for discovering hidden dependencies, discovering the root causes of crashes, and interpreting unexpected results. Explore debugging tools like IntelliJ IDEA Debugger, JConsole, and Heap Dump Analyzer; and find new coverage on modern Java, cloud-native Java applications, and microservices. Each technique is explored with a hands-on project, such as debugging a slow REST API, resolving a memory leak in a web app, and tuning for high performance.

About the reader

For intermediate Java developers.

About the author

Laurentiu Spilca is a skilled Java and Spring developer and an experienced technology instructor. He is the author of Spring Start Here and Spring Security in Action.

360 pages, Paperback

Published November 18, 2025

Reviews

[German Gonzalez · Rating 5 out of 5]

A book where the art of troubleshooting is summarized into best practices and clearly explains what happens under the hood of the JVM is always welcome.

"Java Troubleshooting, 2nd Edition" delivers exactly that, offering a practical and straightforward guide for solving complex issues in Java applications.

Memory & Heap: Having a heap memory leak is sometimes a hard task to diagnose; however, Chapter 11 explains in detail how to detect, analyze, and fix it step by step.

Profiling & Performance: It shows how to find real bottlenecks using tools like JProfiler, VisualVM, and Java Flight Recorder, moving from guesswork to data-driven decisions.

Threads & Concurrency: It describes how to interpret thread dumps, identify deadlocks, and understand thread behavior in production systems.

Transactions & Consistency: Last but not least, data transactions and consistency are the cornerstone of a well-designed application. The book provides details, tips and tricks, and clear explanations that are always helpful for maintaining integrity and stable behavior.

AI-Assisted Troubleshooting: This new edition also introduces AI-based stacktrace analysis, making life easier for developers. It not only highlights how AI can speed up diagnosis but also recommends how to use these new trends responsibly—ensuring AI remains a helpful tool rather than becoming yet another problem to solve.

[Gunnar Prüfer · Rating 5 out of 5]

I can highly recommend the book to anyone looking improving their troubleshooting skills. The more novice and Junior you are, the more you will get out of this book. But also advanced programmers will most likely find tips and tools, that - from my observation - are rarely known or used among developers. Reading GC logs, dropping frames in the debugger, ... The author starts from the basics and most likely you can skip a few paragrahps here and there, but it also ensures that all levels should be able to follow the book.

The author also explains the use of AI in troubleshooting, which is still a new field. Maybe novices will find it useful. I second his recommendation though: Use AI as an assisstant, but do not try to outsource your thinking and expect AI to solve it for you. Train your own muscles.

Very easy to follow all the way through, a fast read. Maybe a bit repetitive at times, but very happy to see that Laurentiu Spilca took the effort to collect all Troubleshooting advice into a book so that such book exists.

[Hugo Guimaraes · Rating 5 out of 5]

Troubleshooting Java is one of those rare technical books that’s both incredibly deep and surprisingly practical. The author clearly knows the subject at an expert level, and it shows on every page.

What I appreciate most is the focus on understanding what your application is actually doing —something we all spend far more time on than writing new code. The book walks through advanced yet very relevant topics, such as using AI to support troubleshooting, identifying performance bottlenecks, detecting memory leaks, analyzing heap dumps and GC logs, and diagnosing communication failures across distributed systems.

Another highlight is the huge collection of hands-on projects included. You can import them directly and practice real troubleshooting techniques instead of just reading theory.

For anyone working with Java in modern, complex environments, this book is an invaluable resource. I highly recommend it and confidently give it 5 stars.

[Gurvinder · Rating 5 out of 5]

I recently finished reading Troubleshooting Java, and I have to say it’s a fantastic guide for anyone working with Java. What I loved most is how it walks you through debugging with tools like IntelliJ and VisualVM, and even dives into tricky areas like threading issues and memory leaks with clear, visual examples. The step-by-step approach makes it super practical for developers starting out, while mid-level engineers will appreciate the real-world debugging techniques. Even senior devs will find it a great refresher on tools and best practices. What really sets this book apart is how it combines theory with hands-on visuals, making complex debugging concepts feel approachable and actionable. It also helps you truly understand what your code is doing under the hood and how different services interact with each other, which is invaluable for diagnosing issues in distributed systems. If you’re into Java, you will enjoy this book.

[Sachin · Rating 5 out of 5]

This book helps you understand what your Java code is really doing when it runs, not just how to write it. Laurentiu Spilca shows you how to find and fix problems like memory leaks, frozen threads, and slow performance in modern systems.

What makes this book special is that you can actually practice what you learn. Every topic comes with real projects you can download and work on yourself—it's not just reading about concepts. The book teaches you how to use important debugging tools like IntelliJ Debugger, VisualVM, and Java Flight Recorder in a way that's easy to follow.

This book works for everyone—beginners learning the basics and experienced developers looking for a complete reference. The author gives smart advice about AI tools: use them to help you, but don't let them do your thinking for you.

[Koushik S · Rating 5 out of 5]

Laurentiu Spilca did an excellent job walking through troubleshooting steps with clarity and depth, making the content especially valuable for junior to intermediate developers. Even for senior developers, the book offers a fresh perspective, especially in today’s AI-driven landscape by showing how AI can be incorporated into troubleshooting workflows in thoughtful and practical ways. The tools, code samples, and execution instructions are presented in a very accessible manner, making it easy to follow along. It’s also clear that the author put a lot of care into capturing details that are often overlooked or considered too small to mention, which adds significant value to the overall learning experience.

[Nestor Huallpa · Rating 5 out of 5]

An incredibly practical and direct read for every engineer role, from trainee to SR staff/Principal engineer, who must manage daily troubleshooting tasks. Chapter 3 guided me in how to use profiling tools to identify problems with CPU, memory, and thread issues, and chapter 12 showed how to apply mechanisms to implement monitoring to troubleshoot in a distributed ecosystem with microservices, API, queues, and so on. It balances strong fundamentals with practical, tool-referenced examples, making it a definitive resource for any modern engineer.

[Simona · Rating 5 out of 5]

Troubleshooting Java is a practical, straight-to-the-point book that tackles a core developer challenge: understanding, analyzing, and fixing existing Java code.

Profiling, advanced debugging, heap and thread dump analysis, effective logging, and JVM behavior are explained through clear, real-world examples. The book goes beyond tool usage, teaching how to think about code and its problems.

Recommended for intermediate Java developers, it’s an excellent read for anyone who spends more time maintaining code than writing it and wants to do so faster and more effectively.

[Sergio Britos · Rating 5 out of 5]

I’d highly recommend Troubleshooting Java, Second Edition by Laurențiu Spilcă — it’s a practical, hands-on guide to diagnosing and fixing subtle bugs in real-world Java apps. With updated coverage of modern tools (like VisualVM, heap and thread dump analyzers) and even AI-powered techniques, it teaches you how to debug smarter, optimize performance, and pinpoint root causes with confidence. Ideal for intermediate JVM developers.

[Purushotham C · Rating 5 out of 5]

Troubleshooting Java, Second Edition, is an indispensable guide for every Java developer. With clear explanations, practical examples, and real-world troubleshooting techniques, Laurentiu Spilca has created a book that belongs on every developer’s desk. Whether you’re fixing performance bottlenecks, resolving crashes, or diagnosing complex system issues, this book gives you the tools and confidence to get the job done.

- Purushotham C K
Technical Architect,
HCL Tech GmbH, Germany

[Tony Bernardino · Rating 5 out of 5]

Very useful book for any Java developer. Debugging is developers bread and butter and this book provides greats insights on how to level up this skill. The 2nd edition now include some tips also on how to AI tools to further improve debugging skills.

Overall the book is well written, has great examples and easy to follow. Highly recommended for any Java developer, no matter their experience.

[Christoph Schubert · Rating 4 out of 5]

This book gives a lot of good explanations on how to debug issues in your application. Many ideas can even be transferred, to some extent, to other languages.
One star removed for a pretty repetitive writing style. In some parts it feels like multiple versions of the same paragraph were kept in but should have been removed.

[Deepak Kumar · Rating 5 out of 5]

A very useful book that shares deep, practical insights into troubleshooting Java applications. It explains debugging, profiling, and log tracing with great examples, making advanced techniques quite easier to understand. The book also shares concise, actionable tips that can help applying these techniques in day-to-day work.

[Burkhard Nestmann · Rating 5 out of 5]

Very good book to deep dive into Java Troubleshooting. Touches all areas and is very real-live oriented and has lots of examples.

[Sumit Aggarwal · Rating 5 out of 5]

A collection of debugging techniques that one learns with years of experience in software development.

[Harpal · Rating 5 out of 5]

A must-read to understand how to troubleshoot Java applications. The book shows how to create systems that are easy to troubleshoot when problems occur. Then it provides a framework for doing the heavy work of understanding what went wrong and which tool is best for the type of problem you encounter.
This book teaches you from the author's experience, which I share as well. Could have been good when I started working with Java.