Customer Reviews

Java Performance Tuning

5 star:		(27)
4 star:		(9)
3 star:		(2)
2 star:		(6)
1 star:		(2)

 

 

The book ranges rather widely, covering a huge number of tuning details. The author seems to know hands-on performance tuning very well, and many of the examples were directly applicable to our own development. There is only one chapter on designing for performance (I would have liked more), but in that chapter he did identify precisely the issues that we encountered in our project. The example of double sorting internationalized text transferred directly to our project and speeded up a crucial area of our presentation. I do recommend this book, but do not expect a design book. This is strongly hands-on performance tuning.

This book provides good ideas on tactical optimization for performance gain but could have also covered architectural patterns and process for performance optimization.
This book covers the areas of optimizing compilers, I/O, RAM footprint, small object management and deployment etc.

Next edition may also cover architectural decisions (or patterns) which are costly to reverse later. Also, coverage on processes for performance optimization will be great in next edition. Getting a program to run faster costs money, and thus this business decision should have process ( or guidelines for series of high level actions ) to facilitate the optimization.

Other things, I would like to cover in next edition are
1) How to choose between "speed up the slow things" or "do the slow things less often".
2) How to identify ACTUAL areas of improvement. i.e. Importance of automated run that reasonably simulates the program under its usual conditions. (Example, our test on performance gave excellent results. But European customers rejected the product because we had not simulated ocean hop of packets as 2 databases were in America. Or importance of using a multi-user simulation system to identify real problems i.e. transaction interactions etc).
3) Importance of cohesive, loosely coupled and well factored modules for behaviour-preserving transformations of performance.
4) Importance of measurement before starting optimization.

Anyway, great book.

This book is diverse in it's approach to java performance tuning. It is very good at describing common bottlenecks in detail and providing concrete examples of how to write better performing code.

It has good coverage of topics including Object creation, I/O and sorting. It illustrates efficient ways to write loops and switches and provides insight into the performance costs of exceptions and casts. 'Java Performance Tuning' also shows how to implement class specific collection classes among other topics.

It takes a comprehensive look at the java profiling tools available and gives illustrated advantages of applying specific techniques. Performance results are contrasted for the various JVMs (JDK1.2 with and without JIT, JDK1.3, Hotspot 1.0).

'Java Performance Tuning' has improved my programming and will sit on my shelf as an excellent reference I know I can turn to if asked to tune a Java application.

I fail to understand the prior critical messages. One said that the author didn't present an accurate description of Reference objects. Well, the description starting on page 108 matches the one I was given by Sun in their performance workshop I attended in Mountain View. So I guess Sun does not know what they are doing in terms of Reference objects :).

Another message claimed that this book was not useful for enterprise applications. To the contrary, I was very impressed with the way he covered the actual process of doing performance analysis, he didn't just present a bunch of individual tips. Many people neglect this in enterprise development - they spend a bunch of time eyeballing the code and trying to do some quick fixes when they really need to set up a harness and do some serious testing.

We used about a dozen of the techniques from the book and our component went from being a real dog to way fast enough. Given what we achieved with the basic techniques, most of the more advanced techniques are unlikely to ever be used by us, but they were interesting and might come in useful one day. The book paid for itself within a day. Definitely useful if you have or anticipate a performance problem.

Java Performance Tuning reveals how techniques such as minimizing object creation, replacing strings with arrays, and other techniques can improve code performance. Author and Java expert Jack Shirazi also offers common-sense advice about what to tune and what to leave alone in order to maximize performance while avoiding damaging a program's architecture. Highly recommended as both an instruction manual Java users, Java Performance Tuning is a very well presented, highly recommend, "user friendly" reference that is enhanced with performance tuning checklists enabling developers to make their tuning as comprehensive and effective as possible.

This book analyzes what it is that makes many Java programs slow and what can be done to speed them up. Many of the examples exhibit speed increases of 20x-100x! Mr. Shirazi doesn't just talk about optimizing your switch statements so they use the table-lookup version of the bytecode (although that is covered), which is one of the low-level optimizations that will sometimes double the speed of a critical section, but also shows how to implement more profound algorithmic optimizations - the kind that can give order-of-magnitude speedups or better.
Memory management is covered, including excellent coverage of object creation, what the overhead REALLY is, how to reduce it by reusing objects, avoiding primitive wrapper classes, and other optimizations.
There is also suberb advice on algorithms (sorting, searching, data structures), I/O, multithreading (LOTS of fun, as always), character encoding optimization, and the fascinating but complex world of distributed computing.
A good distinction is made between the kinds of optimizations that are simply good coding practices and should be practiced regularly (such as using StringBuffers instead of Strings with the + operator) and those that, while being good for performance, are bad for design and increase maintenance costs. So Mr. Shirazi shows us that we can never know what will be slow until we profile, profile, profile. And the profiling done throughout the book doesn't use expensive commercial products, but simple timing code discussed in the first couple chapters.
Overall, a book I very much enjoyed reading and I highly recommend it.

I notice that this book got the best review in John Zukowski's comparative review of Java performance books in Javaworld.

"Java Performance Tuning" by Jack Shirazi has written a fairly comprehensive account on Java performance problems. The book is geared towards a programmer with medium level of experience with Java technology, it requires familiarity with basic Java techniques and with basic understanding of JVM design. For experienced programmer, most of the material mentioned will be familiar, just by virtue of programming in Java for a few years one will encounter most of the problems outlined.

Mr. Shirazi starts with outlining the profiling strategies and basic available tools. From that he proceeds towards topics in object creation, GC, string manipulation, exceptions, loops , I/O, threading models, caching strategies, distributed computing, and some very brief mention of the underlying OS issues. Most of the material states the problem (which is almost always the most important part), tells you how to identify it, and sketches a few solutions. It is not a programming recipe book by any stretch of imagination. Hope is that as one will read the book, he/she will think about performance up front and will become a better programmer as the result.

Arguably, what the book fails to explain is JVM and Java internals, which will provide an insight on why things happen the way they happen. I would appreciate more coverage on available performance benchmarks (which are only briefly mentioned), and/or on how to write a good performance testing case for each of the optimizations outlined.

You have been working on that Java application for two weeks and it's finally ready for testing. Your window for having the web site down is ten minutes but you aren't concerned. Three hours later with the program still running, you are more than concerned. Before you panic, pick up a copy of "Java Performance Tuning". This book is geared for serious developers who need to dramatically improve performance in their applications and are willing to dig deep into the code. For example, writing your own customized Reader and byte-to-char converter can be ten times faster than using the BufferedReader class. Shirazi starts off by showing how to measure performance and identify bottlenecks, including a way to override the Object class to measure object creation. Subsequent chapters discuss key performance issues and possible solutions. Topics covered include replacing Strings with char arrays, eliminating casting and minimizing object creation, removing method calls from inside of loops, writing your own sort routines instead of using Arrays.sort(), identifying the correct Collection object, using threading to improve performance, and optimizing distributed systems to decrease network communication. As Shirazi explains, some of the methods covered may violate encapsulation or other OO techniques so they should only be used when performance has been identified as a critical problem. Besides being well written, the book is fun. I found myself trying to figure out along with the author how to improve the performance of the various examples demonstrated in the book.