1. Chapter 1 Introduction

   1. Why Is It Slow?

   2. The Tuning Game

   3. System Limitations and What to Tune

   4. A Tuning Strategy

   5. Perceived Performance

   6. Starting to Tune

   7. What to Measure

   8. Don't Tune What You Don't Need to Tune

   9. Performance Checklist

2. Chapter 2 Profiling Tools

   1. Measurements and Timings

   2. Garbage Collection

   3. Method Calls

   4. Object-Creation Profiling

   5. Monitoring Gross Memory Usage

   6. Client/Server Communications

   7. Performance Checklist

3. Chapter 3 Underlying JDK Improvements

   1. Garbage Collection

   2. Replacing JDK Classes

   3. Faster VMs

   4. Better Optimizing Compilers

   5. Sun's Compiler and Runtime Optimizations

   6. Compile to Native Machine Code

   7. Native Method Calls

   8. Uncompressed ZIP/JAR Files

   9. Performance Checklist

4. Chapter 4 Object Creation

   1. Object-Creation Statistics

   2. Object Reuse

   3. Avoiding Garbage Collection

   4. Initialization

   5. Early and Late Initialization

   6. Performance Checklist

5. Chapter 5 Strings

   1. The Performance Effects of Strings

   2. Compile-Time Versus Runtime Resolution of Strings

   3. Conversions to Strings

   4. Strings Versus char Arrays

   5. String Comparisons and Searches

   6. Sorting Internationalized Strings

   7. Performance Checklist

6. Chapter 6 Exceptions, Casts, and Variables

   1. Exceptions

   2. Casts

   3. Variables

   4. Method Parameters

   5. Performance Checklist

7. Chapter 7 Loops and Switches

   1. Java.io.Reader Converter

   2. Exception-Terminated Loops

   3. Switches

   4. Recursion

   5. Recursion and Stacks

   6. Performance Checklist

8. Chapter 8 I/O, Logging, and Console Output

   1. Replacing System.out

   2. Logging

   3. From Raw I/O to Smokin' I/O

   4. Serialization

   5. Clustering Objects and Counting I/O Operations

   6. Compression

   7. Performance Checklist

9. Chapter 9 Sorting

   1. Avoiding Unnecessary Sorting Overhead

   2. An Efficient Sorting Framework

   3. Better Than O(nlogn) Sorting

   4. Performance Checklist

10. Chapter 10 Threading

    1. User-Interface Thread and Other Threads

    2. Race Conditions

    3. Deadlocks

    4. Synchronization Overheads

    5. Timing Multithreaded Tests

    6. Atomic Access and Assignment

    7. Thread Pools

    8. Load Balancing

    9. Threaded Problem-Solving Strategies

    10. Performance Checklist

11. Chapter 11 Appropriate Data Structures and Algorithms

    1. Collections

    2. Java 2 Collections

    3. Hashtables and HashMaps

    4. Cached Access

    5. Caching Example I

    6. Caching Example II

    7. Finding the Index for Partially Matched Strings

    8. Search Trees

    9. Performance Checklist

12. Chapter 12 Distributed Computing

    1. Tools

    2. Message Reduction

    3. Comparing Communication Layers

    4. Caching

    5. Batching I

    6. Application Partitioning

    7. Batching II

    8. Low-Level Communication Optimizations

    9. Distributed Garbage Collection

    10. Databases

    11. Performance Checklist

13. Chapter 13 When to Optimize

    1. When Not to Optimize

    2. Tuning Class Libraries and Beans

    3. Analysis

    4. Design and Architecture

    5. Tuning After Deployment

    6. More Factors That Affect Performance

    7. Performance Checklist

14. Chapter 14 Underlying Operating System and Network Improvements

    1. Hard Disks

    2. CPU

    3. RAM

    4. Network I/O

    5. Performance Checklist

15. Chapter 15 Further Resources

    1. Books

    2. Magazines

    3. URLs

    4. Profilers

    5. Optimizers

1. Colophon

Our look is the result of reader comments, our own experimentation, and feedback from distribution channels. Distinctive covers complement our distinctive approach to technical topics, breathing personality and life into potentially dry subjects. The image on the cover of Java Performance Tuning is a stopwatch. Unlike traditional clocks, which track the continuation of time through the minutes and hours of a day, the stopwatch measures elapsed time over short intervals by allowing the user to start and stop it. This is particularly suited to sports: stopwatches (also known as chronographs) were common at English horse races as early as the mid-seventeenth century. However, a stopwatch like the one pictured on the cover is prone to human error: its exactness is limited by the reaction times of the person holding it. Although more precise photographic-electric timers appeared as early as 1892 and were used experimentally in the Olympic Games in Stockholm in 1912, the Olympics continued to rely on handheld stopwatches until 1960 in Rome, when the transition was officially made to electric timers. Emily Quill was the production editor and proofreader for Java Performance Tuning. Mary Anne Weeks Mayo was the copyeditor for the book. Jane Ellin and Nancy Kotary performed quality control reviews. Nancy Williams provided production assistance. Nancy Crumpton wrote the index. This colophon was written by Emily Quill.

Hanna Dyer designed the cover of this book, based on a series design by Edie Freedman. The image of the stopwatch is from the Stock Options photo collection. It was manipulated in Adobe Photoshop by Michael Snow. The cover layout was produced by Emma Colby using QuarkXPress 4.1, the Bodoni Black font from URW Software, and BT Bodoni Bold Italic from Bitstream. Alicia Cech and David Futato designed the interior layout, based on a series design by Nancy Priest.

Text was produced in FrameMaker 5.5.6 using a template implemented by Mike Sierra. The heading font is Bodoni BT; the text font is New Baskerville. Illustrations that appear in the book were created in Macromedia Freehand 8 and Adobe Photoshop 5 by Robert Romano and Rhon Porter.

Whenever possible, our books use a durable and flexible lay-flat binding. If the page count exceeds the maximum bulk possible for this type of binding, perfect binding is used.