book

Troubleshooting Java

by Laurentiu Spilca

April 2023

Intermediate to advanced

328 pages

8h 31m

English

Manning Publications

Read now

Unlock full access

Tips for applying investigation techniques
prefaceacknowledgmentsabout this bookWho should read this bookHow this book is organized: A roadmapAbout the codeliveBook discussion forumAuthor onlineabout the authorabout the cover illustration
1.1 How to more easily understand your app1.2 Typical scenarios for using investigation techniques1.2.1 Demystifying the unexpected output1.2.2 Learning certain technologies1.2.3 Clarifying slowness1.2.4 Understanding app crashes1.3 What you will learn in this bookSummary
2.1 When analyzing code is not enough2.2 Investigating code with a debugger2.2.1 What is the execution stack trace, and how do I use it?2.2.2 Navigating code with the debugger2.3 When using the debugger might not be enoughSummary
3.1 Minimizing investigation time with conditional breakpoints3.2 Using breakpoints that don’t pause the execution3.3 Dynamically altering the investigation scenario3.4 Rewinding the investigation caseSummary
4.1 What is remote debugging?4.2 Investigating in remote environments4.2.1 The scenario4.2.2 Finding issues in remote environmentsSummary

5.1 Investigating issues with logs5.1.1 Using logs to identify exceptions5.1.2 Using exception stack traces to identify what calls a method5.1.3 Measuring time spent to execute a given instruction5.1.4 Investigating issues in multithreaded architectures5.2 Implementing logging5.2.1 Persisting logs5.2.2 Defining logging levels and using logging frameworks5.2.3 Problems caused by logging and how to avoid them5.3 Logs vs. remote debuggingSummary
6.1 Where would a profiler be useful?6.1.1 Identifying abnormal usage of resources6.1.2 Finding out what code executes6.1.3 Identifying slowness in an app’s execution6.2 Using a profiler6.2.1 Installing and configuring VisualVM6.2.2 Observing the CPU and memory usage6.2.3 Identifying memory leaksSummary
7.1 Sampling to observe executing code7.2 Profiling to learn how many times a method executed7.3 Using a profiler to identify SQL queries an app executes7.3.1 Using a profiler to retrieve SQL queries not generated by a framework7.3.2 Using the profiler to get the SQL queries generated by a framework7.3.3 Using the profiler to get programmatically generated SQL queriesSummary
8.1 Detecting problems with JDBC connections8.2 Understanding the app’s code design using call graphs8.3 Using flame graphs to spot performance problems8.4 Analyzing queries on NoSQL databasesSummary
9.1 Monitoring threads for locks9.2 Analyzing thread locks9.3 Analyzing waiting threadsSummary
10.1 Getting a thread dump10.1.1 Getting a thread dump using a profiler10.1.2 Generating a thread dump from the command line10.2 Reading thread dumps10.2.1 Reading plain-text thread dumps10.2.2 Using tools to better grasp thread dumpsSummary
11.1 Sampling and profiling for memory issues11.2 Using heap dumps to find memory leaks11.2.1 Obtaining a heap dump11.2.2 Reading a heap dump11.2.3 Using the OQL console to query a heap dumpSummary
12.1 Investigating communication between services12.1.1 Using HTTP server probes to observe HTTP requests12.1.2 Using HTTP client probes to observe HTTP requests the app sends12.1.3 Investigating low-level events on sockets12.2 The relevance of integrated log monitoring12.3 Using deployment tools in investigations12.3.1 Using fault injection to mimic hard-to-replicate issues12.3.2 Using mirroring to facilitate testing and error detectionSummary
D.1 What is a thread?D.2 A thread’s life cycleD.3 Synchronizing threadsD.3.1 Synchronized blocksD.3.2 Using wait(), notify(), and notifyAll()D.3.3 Joining threadsD.3.4 Blocking threads for a defined timeD.3.5 Synchronizing threads with blocking objectsD.4 Common issues in multithreaded architecturesD.4.1 Race conditionsD.4.2 DeadlocksD.4.3 LivelocksD.4.4 StarvationD.5 Further reading
E.1 How the JVM organizes an app’s memoryE.2 The stack used by threads to store local dataE.3 The heap the app uses to store object instancesE.4 The metaspace memory location for storing data types

Overview

Effectively reading and understanding existing code is a developer’s superpower. In this book, you’ll master techniques for code profiling, advanced debugging, and log evaluation to find and fix bugs and performance problems.

In Troubleshooting Java: Read, debug, and optimize JVM applications you will learn how to:

Determine what code does the first time you see it
Expose code logic problems
Evaluate heap dumps to find memory leaks
Monitor CPU consumption to optimize execution
Use thread dumps to find and solve deadlocks
Easily follow a service-oriented or microservices system
Properly use logging to better understand Java app execution
Use Java debuggers efficiently

Searching for bugs, detangling messy legacy code, or evaluating your codebase for new features sucks up much of a developer's time. Troubleshooting Java: Read, debug, and optimize JVM applications teaches 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. You’ll go from the basics of debugging to advanced methods for locating problems in microservices architectures, and save yourself hours—or even days—of time. Each new technique is explained with lively illustrations and engaging real-world examples.

About the Technology
Fact: Over the course of your career, you’ll spend far more time reading code than you will writing it. The code investigation skills in this book will radically improve your efficiency in understanding and improving Java applications.

About the Book
Troubleshooting Java: Read, debug, and optimize JVM applications presents practical techniques for exploring and repairing unfamiliar code. In it, you’ll learn timesaving practices for discovering hidden dependencies, discovering the root causes of crashes, and interpreting unexpected results. Go beyond profiling and debugging and start understanding how Java applications really work.

What's Inside

Determine what code does the first time you see it
Evaluate heap dumps to find memory leaks
Monitor CPU consumption to optimize execution
Use thread dumps to find and solve deadlocks
Uncover glitches in code logic
Locate intermittent runtime problems

About the Reader
For intermediate Java developers.

About the Author
Laurențiu Spilcă 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.

Quotes
We spend more time trying to understand code than writing it. This book shows you how to use that time wisely.
- Brent Honadel, Infor

Finally a book that illustrates how to troubleshoot and reason about Java apps in production! It just might save the day!
- Atul Shriniwas Khot, SquareOne Insights

I wish I had this collection of efficient and usable techniques at the beginning of my career.
- Andriy Stosyk, EPAM Systems

A great book with deep explanations about debugging techniques.
- Cătălin Matei, Endava

Understand how Java applications work under the hood.
- Fernando Bernardino, Wise