Java Performance (Java (Addison-Wesley)) [Paperback]

This is an outstanding book and one of the few that, even after working through, I'll be keeping within reach at my desk. After almost a decade working on the JVM, I've only recently begun work on some software that really strains our systems, processing a million and some records a day with several instances each on multiple threads, and so until recently, performance has always been a secondary concern. While the app's code is certainly not perfect, I started wondering whether any of the mysterious extended options available to the JVM might take some of the weight off the system without having to wait until the next formal development/release cycle. This is what prompted me to look at this book, but as I'll describe, I found much more.

I was very impressed with the amount of information provided: unlike most computer-related books, this is dense with text, rather than long code samples, screenshots and diagrams. Why is this a good thing? This is not just a book on how to use the JVM and its related performance tools, but also a book on the JVM's internal architecture (including its memory model and garbage collectors) and on the art of benchmarking and performance testing. Though the prose can be dry, the authors are very patient about describing these topics to readers in a clear way, and sometimes with great detail. OTOH, as this is written with experienced developers in mind, beware that it can at times be challenging (even for someone who's done their fair share of coding!).

There are a few major areas covered:

1) Tuning the JVM. This usually involves applying command-line options to the JVM executable (I can almost guarantee you'll discover you have more control over the JVM than you thought you did!) The authors cover the JVM internal architecture, garbage collection and memory model to provide context on what these options actually do, as well as extensive descriptions of how and when to use the options.

2) Performance monitoring tools, profiling, heap-dump analysis. Much of the book is devoted to describing not only the tools available in the JDK, but those provided by popular OSes and 3rd parties.

3) Writing benchmarks. There is more an art to this than you might expect, especially when writing benchmarks for the JVM. Tips on benchmarking different types of applications (i.e. webapps, web services) are separated into different chapters.

The biggest downside, as another reviewer pointed out, is it's 'oracle-centricity'. For example, you'll find much said on Netbeans and Glassfish, while Eclipse and Tomcat don't get a single mention. These are tools that we all know about, but what great, more obscure, tools am I missing out on due to this obvious bias? This seriously damages the credibility of the authors as far as tool-selection is concerned, but in the end, it's the JVM and the performance testing concepts that are most important. Once I learn the vocabulary, I'll be able to figure out through Google which tools are best.

This book is essentially a compilation of all internal product documentations and freely available online tutorials without good examples to corroborate the theories presented throughout the book. It discusses JVM tuning as an infinite set of variables, which look more like infinite variety and challenges to the reader than anything concrete and useful. It is an "okay" book if you just want to "read" about Java performance, but if you have a real project and a real Java performance issue to deal with, you'll have to try out all the permutations and find out yourself which ones are helpful and which ones are not - only if you have infinite amount of time to do so. In reality, sometimes we just want to get a Java performance issue resolved as quickly as possible so that we can move on to the next task on our busy agenda. This book has clearly failed to meet the basic criterion of being data-driven to be a practical, useful guide to helping readers resolve their Java performance issues they encounter with their projects. I hope the lead author can help improve it if he gets a chance to update this book in future.

The last book to cover this topic n any detail was Steve Wilson et al's "Java Platform Performance", which was published in 2000. HotSpot has moved on a fair bit since then, so its good to see a new book covering the subject.

The sections on JVM tuning and profiling are particularly strong. There's also a decent section on HotSpot Garbage Collectors, though I would have liked to see some more discussion on alternative GC algorithms such as IBM's Balanced Garbage Collector and Azul's C4.

It should be noted that there is a definite bias towards Oracle's tools and hardware. For example the section on "Choosing the Right CPU architecture" concentrated mainly on Oracle's SPARC chips. Also the two profilers featured are the Oracle Solaris Studio Performance Analysiser Tool, and the NetBeans profiler. Likewise in the Java EE Section all the examples are based on Glassfish.

The book doesn't provide a recipe for solving every problem, but does provide enough information for non-performance specialist developers and others involved in application performance tuning work, to solve the majority of commonly encountered performance problems.