(...)
This is a substantial and comprehensive text on many aspects of Java Performance characteristics, explaining the effects of Java design and coding practices, and giving advice to help the Java Programmer design, code, and optimize applications to execute efficiently. It is not a programming tutorial for the novice, but will enhance the knowledge of an experienced programmer for Java specific concepts. Its goal is to explain how to tune existing programs to improve efficiency, but the explanation of the underlying Java Virtual Machine and the details of compiler code generation are so revealing that any developer will gain valuable insight into smart Java programming design.

The book consists of 537 pages divided into 19 chapters and is quite easy to understand for readers who have programming experience. Each chapter ends with a performance checklist section to summarize what you need to do with regard to that chapter's illumination.

The clearly organized chapters permit you to selectively read any of interest because they are mostly independent subjects. You can read a chapter on Strings and learn all about how these objects are implemented and the ramifications of various usages. It also addresses some algorithmic issues, such as sorting, garbage collection, and threading. I thought many of the revelations of code generation and object storage will seem obvious to programmers who have experience looking at generated code in other languages which will make for fast reading.

The very comprehensive nature of the book provides valuable information for all Java developers, and yet is helpful for just a quick understanding of particular Java issues. I enjoyed just reading through some of the chapters to confirm or enhance my understanding of particular execution characteristics.

(...)

I rate this book 4 out of 5 for programmers with Java experience.

Note: this book has nothing to do with Java Scripts.

I saw many reviews of this book are full of praise but none of the reviewers actually mention having used it in large enterprise or production-ready systems! Huh, was the book written as an academic paper or a practical reference?

Many of the reviewers don't seem to have read the book to begin with. I had to really laugh at Bob Mann, he seems to have spent more time reading the reviews of this book in magazines than spending time to find the facts, or performance-tuning an app using the suggestions here. Looks like this guy has never supported any production system to know what kind of 'hairy' codes can be allowed in the codebase.

The performance comparisons provided in this book are confusing, inconclusive at the best, and many suggestions are just vaporware, no way to 'implement' those tunes.

Another reviewer, invalidated all criticisms that this book is useless for enterprise development, by enterprise developments I believe applications using EJB, JMS, RMI-IIOP, MVC/Struts are all covered, show me a single line written in this book which covers performance problems encountered in these areas.

I'll state up front I'm a friend of the author, so this is partisan. I completely disagree on a point of fact with the earlier "culturally interresting but professionnally almost useless" review by an anonymous reader. He states that he resumes the book with 'could resume this book by..."don't code in Java, do it directly in C"'. But that is the exact opposite of what is in the book. At no point does Jack ever suggest that
you would be better off doing it in C. Quite the opposite, Jack even shows that you can get your application in Java to be faster than the equivalent C program. How you could have read the book and come away saying the exact opposite of what it says is beyond me!

Java Performance Tuning would be a good book to have if you have a seriously performance intensive application or for someone who just really dug performance issues. But it wouldn't be of interest to most people. Most programmers should be able to do all the performance tuning they need to do with a program like Optomizeit.

I could resume this book by..."don't code in Java, do it directly in C"..it remembers me when I was a young C programmer I read a book on performance in C the shortcut was "Don't code in C do it directly in Assembler".

I really enjoyed this book for my programming general culture but for my professionnal day to day it seemed to me almost useless because I work on large J2EE projects.
If I were building a high accessibility web site hosted on a pentium 100 with 8MB ram I would use these techniques but my clients have money and business requierements so I will just keep this book has a enlighment for my discussions with my programmers buddy.

This is an excellent book, with something like 300 tuning techniques covered. Some techniques are more hairy than others, but the breadth and depth is astonishing. I did extensive research before buying this book. I found that it was in the top 3 editors choice for Java book at Javaworld a couple of times, in the top 20 Java books readers choice at JDJ a couple of times (note that is all "Java" books, not "Java Performance" books), it was the choice of a comparative review of Java performance books, it had good reviews by every professional review I could find, and finally, after having read it, it is one of the few Java books I keep handy as a reference.

Looking down at some of the other reviews here at Amazon, I see most people agree with me too. There are some nitpickers. I had to laugh at sudiptokanti, he seems to have decided the book was too dangerous for him. Certainly there are suggestions in the book of hairy performance tunes, as there are many more of perfectly good best practice tunes. And, as the author points out, you should not be using these techniques except after you have identified a bottleneck. sudiptokanti seems to have reviewed the book as if it is a development guide rather than what it is: an excellent guide on performance tuning your applications.

Newbies, please take the author's sugessions with a big pinch of salt, please do not go ahead and rewrite JDK classes as author says, and about 'ensuring that the defragmentation procedure does not disrupt your own use of disk sweet spots' - ask the author how. I must confess some parts of the book (a very small part though) are informative, and that alone earned the second star in this review, else I would have had no compunction to stick it with a single star.

It would not take more than a casual browse-thru for an experience java developer to call the bluff, I'm concerned that some newish practitionars might end up in deep water following these suggestions.

Firstly, this book comes nowhere near discussing any J2EE performance topics, though nowadays it's difficult to find plain vanilla java implementations. The author did devote a whole chapter on distributed computing, I expected to find discussions on tuning parameters for EJB deployment descriptors there; nope, he decided to discuss server-object implementation of CORBA and RMI instead, he compared them, compared different communication layers and other stuff, in short he explained to you everything about the components you have no control over! This book in most cases concentrates on topics only of academic interest, except for some discussion on code styles I found next to nothing to take away from this book.

Author has given enough number of tables with performance comparisons to fill half the space for the book, but understand that these results are only indicative of what might happen for a particular program on a particular system, I'm not even going to the detail to tell you that in some cases the results and table heading say completely different things (e.g. Table 7.2 Speedups using Exception-driven loop termination actually compares timing across different switch approaches), that reminds me, I have to compile a 'don't do' list to be used along with this book

Do not
- replace JDK classes: it would be unfair to say that the author himself has not warned you against it, but let me also quote him "For optimal performance, I recommend developing with your own versions of classes rather than JDK versions whenever possible." I find it outright funny, I almost can't believe (except for the fact that the rest of the book is in keeping with it) that he is actually suggesting something so ridiculous as this, I wonder whether somebody in Microsoft listened to him before they got into a legal tussle with sun about copyright.
- depend on optimizations with -O
- compile to native machine code (go use C++)
- get hooked on to native method calls: to quote the author "say goodbye to 100% pure java certification, and say hello to added complexity..." so it's not that the author has no idea of what he was talking about... still those siggestions? makes the book thicker ;-)
- reuse Exception objects
- get hooked onto the concept of comparison by identity, in short do not make significant modifications to your codes to get a comparison by identity, do not define a 'public static final Integer ZERO = new Integer(0)'
- use WeakReferences
- converts Strings to char arrays
- write exception-terminated loops
- and a lot of other things

I gather I have made my point, do not buy this book unless you want to write blazingly fast applications those do not work right and is a nightmare to maintain.

This edition provides substantial benchmarks which thorough includes coverage of the JDK including loops, exceptions, strings, threading, and even underlying JVM improvements in the 1.4 VM. This book is one of a kind in its material and completeness.

In my opinion, the author doesn't spend as much time on J2EE as is spent on J2SE chapters. I was excited to all of the stats and examples on J2SE, but was let down when there was nowhere near as much emphasis on J2EE. Many of the J2SE performance practices still apply for J2EE, but it would be useful to strengthen these chapters with actual performance metrics.

This book is indispensable for the developer that is designing the performance requirements and the processes for proper testing. In addition to containing excellent advice, it's the most up to date publication dealing specifically with performance of Java applications.

This review is for the second addition. I have attended performance workshops and I have never found a resource as complete and thorough as this book. It is an indispensable guide to any developer looking to make their code more efficient. It goes without saying that it is probably intended for the intermediate to advanced programmer. The book is by no means superficial. Its coverage is deep and to the point. What I found useful were the number of performance metrics under various JVMs using different programmatic methods/classes. This book is more like a reference and I don't advise you read through it from front to back. The amount of information is overwhelming. My suggestion is to pick a topic that is of issue and read about it. I saw a previous review that blasted the book for having only one page for JDBC and database issues. This must be from the first edition (I only read the 2nd) because the second edition has a whole chapter (some 45 pages worth) on JDBC. Another criticism I saw was that the book lacked design patterns, it refers to. While this is often true, I don't believe this book attempts to teach you design patterns. There are whole books on this topic. I suggest you read Core J2EE design patterns if you want to know what they look like. Like I said, this book is for the intermediate to advanced programmer and it does not attempt to hash out design patterns.

Now in an updated second edition that covers Java SDK 1.4 and J2EE performance tuning, Java Performance Tuning: Efficient & Effective Tuning Strategies by Java programming expert Jack Shirazi is a solid and superbly presented instructional resource and reference for advanced computer programmers wanting to improving their Java program performances, ranging from optimizing input/output routines, to speeding up servlets, to making the most of profiling tools, to searching out program bottlenecks, to applying appropriate sorting and other algorithms, and much, much more. A solid and comprehensive guide offering plenty of examples and sample code in addition to the well-reasoned text, Java Performance Tuning is an ideal and strongly recommended addition to any Java user's reference personal or professional reference collection.

Performance has been the albatross around Java's neck for a long time. It's a popular subject when developers get together "Don't use Vector, use ArrayList, it's more efficient." "Don't concatenate Strings, use a StringBuffer, it's more efficient." It's a chance for the experienced developers to sit around the design campfire and tell ghost stories of previous projects where they implemented their own basic data structures {String, Linked List...} that was anywhere from 10-50% faster than the JDK implementation (and in the grand oral tradition of tall tales, it gets a little more efficient every time they tell it). Every developer has written a microbenchmark (a bit of code that does something 100-1000 times in a tight loop and measure the time it takes for the supposed "expensive operation") to try and prove an argument about which way is "more efficient" based on the execution time. The problem is when running in a dynamic, managed environment like the 1.4.x JVM, there more factors that you don't control than you do, and it can be dificult to say whether one piece of code will be "more efficient" than another without testing with actual usage patterns. This book provides substantial benchmarks (not just simple microbenchmaks) with thorough coverage of the JDK including loops, exceptions, strings, threading, and even underlying JVM improvements in the 1.4 VM. This book is one of a kind in its scope and completeness.

This updated edition of "Java Performance Tuning" shows remarkable improvement over its predecessor. In addition to improving its Java 1.4 details, this book journeyed into extra territories in its bid to leave nothing to speculation. Its users would appreciate the additional information it presented on JavaServer Pages, Servlets, Enterprise JavaBeans, Java Database Connectivity, and Java NIO.
Although it provided detailed tuition on how to utilize various profiling tools in analyzing a program's characters, the main aim of this book is to furnish programmers (or developers) with all the information they would need when adopting tuning options.
It ramified every factor which affects Java performance, and would serve as a handy reminder for both developers and administrators alike. I recommended it with all pleasure!

Once the business rules have been settled and all that is left is to tune the code, then the fun starts. Like a race car mechanic trying to squeeze out a couple of extra MPH from a race car, the most fun in programming is to try squeeze out extra performance from some code. A book on performance tuning should understand that and make the topic fun. Reading this book it is clear that Jack Shirazi loves to tune code. He has done an incredible amount of detailed research on different JVMs to determine exactly how to make Java perform. But he is also practical. He explains how to find performance problems, which exact areas to concentrate on, and which areas to ignore. After reading this book you won't waste your time on areas of code that can't be easily optimized and instead you'll know how to concentrate on those places where you can get the most bang. The book has been updated from the earlier edition to bring all the information up to date with the latest JVMs. Best of all, an additional 250 pages has been added to the book covering J2EE including Servlets, JSPs, EJBs, and JDBC. "Java Performance Tuning" is a programmer's book. You are guaranteed to learn a lot of very neat and useful tricks. I doubt that there is another Java book on the market with as many "WOW!" moments in it. Buy it and watch your code zoom.

"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.

This book was totally brilliant. I've been doing Java for five years, and actually got this book nearly two years ago. It is still the best Java book I've read! I came back here because I saw that the 2nd edition is shortly to come out, and it includes all the 1.4 stuff as well as J2EE tuning. I thought I'd let the rest of you know, so that you buy that one rather than this, I hate getting a book only to have the updated edition come out a month later. If there wasn't a 2nd ed, I'd fully recommend this edition. I'll be buying the 2nd ed as soon as I can.

If you're new to performance tuning, and you want to know what it's all about, then this is the book you need. It contains a wealth of tips and techniques, which *will* allow you make a grand entrance on a performance tuning job.
If you want an update on the latest performance-related features of Java, then you definitely don't want this book. It's just to outdated.

I'm still reading the book but I can already see that this title is one of the best in "Java Performance"
area. I can go even further - this title seems to be one of the best Java books I've ever read.
The author is a serious Java developer (geek, hacker, whatever you call it) who's going nuts
to achieve a better performance for his applications (he even keeps his loops going from
N to 0 - it's a bit faster than going from 0 to N). While most other people may advise you
to use a profiler (and Jack is doing this too, of course) he's actually implementing a couple
of mini-profilers by himself. The depth he covers the material is probably the deepest you can
meet today - unfortunately, not so many authors are even trying to cover all necessary details,
but if Jack is going to talk about something - you're going to hear almost everything you'll
ever need (if "Java Platform Performance: Strategies and Tactics" authors are only mentioning
optimizing compilers - Jack is explaining what are they, what are they doing, how are they doing
it, what are consequences to what they're doing .. you get me).

Personally, I wouldn't agree with everything he offers (and I'll never replace any String class,
Jack!), but this books is still a highly valuable source of optimization and performance tuning
information. I can't recommend it more.

Jack is also maintaining a Web-site (javaperformancetuning.com) full of excellent information and
articles reviews. Frankly, if it's not in his book or Web-site - I believe it simply doesn't
exist. Boy, he's so good.

Please, excuse me for a personal bias in this review - I couldn't keep myself from
applauding to Jack. Excellent work, man.

P.S.
A special "thank you" goes to using checklists at the end of every chapter and on the site - I'm
a big fan of checklists and never understood authors ignoring such a simple but
powerful technique.

Not only does Jack Shirazi provide an array of useful benchmarks in "Java Performance Tuning", both at the micro and macro level, he provides excellent case studies on how to set up and run benchmarks. Results are given for JDK versions 1.1.6, 1.2, and 1.3 with and without HotSpot. Although it would be nice to get a more up to date test including 1.4 and other run times, the utility of this book goes far beyond what it reports about the compilers and run times available in late 2000.

The high level advice on a tuning methodology (profile and target, of course) is sound, as is the emphasis on perceived performance. Topics everyone should be aware of from caching to threading to streaming are dealt with up front. This might make this book rather hard to follow for readers unfamiliar with these concepts. Further advice on how to measure (try to get close to reality) and to not tune what you don't need to tune are also sound pieces of advice that are often overlooked.

Admirable attention to garbage collection and command-line tuning of the run-times and compilers increased my confidence in the results, and should serve as a model to other benchmarkers. Details considered include everything from cache size and disk framentation to network bottlenecks.

There are too many useful sections to list here. The writing is crisp and clear, the pace fast, and the examples well chosen. Shirazi provides depth on topics ranging from low level constructs such as switch statements, method calls, or upcasts, through intermediate constructs such as threading and object creation and reuse, to higher-level constructs such as the String and Collection classes. In chapter 8, the section "From Raw I/O to Smokin' I/O" alone justifies having this book on your shelf.

This book is about tuning. It is not a book about algorithms or algorithm analysis. You'll need to know that, too. An elegant bridge between tuning and algorithms can be found in Jon Bentley's "Programming Pearls".

All told, "Java Performance Tuning" is the best book on tuning I've ever read. Don't even bother with Wilson et al.'s "Java Platform Performance".

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.

Near the end of every major Java project the topic of performance comes up. In some cases the use of a pricy profiling tool is mentioned or quickly acquired. But, these tools while showing you bottlenecks, etc do little in the way of dealing with the "now what?" of after you've profiled a system. While some obvious improvements can be made (e.g., removing exceptions as part of normal execution flow) many times the bottleneck is left under-addressed because it is believed that there is little more that can effectively be done. This book is a GOLD MINE of taking a given area/topic and squeezing out more and more. Replacing Strings w/ char arrays, design points for doing more effective parallelism with threads, etc all of these topics are invaluable. Also as the author states many of these things should be done only AFTER you've identified that spot as a bottleneck in your system (and not blindly implemented everywhere). When performance is on your plate this book is a must have. Personally, if I were a VM Gear or a KL Group given the price range of these tools I would include (at any cost) a copy of this book as a general tuning guide to complement their user's guide for the profiling tool.

This book is the best java book i have read so far and i think this is a must for every java programmer. This book is special in a way where Mr. Shirazi highlights the common mistakes performed while programming and how costly they.

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.

The book covered each area of Java performance except GUI/drawing. The performance techniques covered are many - I counted more than 200 listed in the index. The writer also gave a very good guide to the procedure for tuning applications, so I could start immediately without having to think "what to do next?"

The checklists are very useful. I wanted to have a separate copy of all the checklists so that I could tick them off as I worked. I ended up photocopying them and keeping them a separate resource. I have many Java books, and this is one of the few books which I now keep ready to refer to. Excellent book.

well, I agree with the previsous thought about this books it is very useful book. but I feel it less some topic about the memory management , of course it is a trade of between memory/speed, but it will be nice to talk them together.

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

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 am very disappointed to find out that this book has only one page talking about JDBC and database related issue. Java has been used mostly in commerce applications whose performance is greatly depending on database design, JDBC, stored procedures, etc...

This is an awesome book. One of the best Java books I've read. I was given the task of becoming the "performance expert" in the company,and I've read about five of the perf books that have now come out, and this is definitely the best. My only comment is that I wish it was twice as long. Excellent, defintely recommended.

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.

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 is an excellent book by an experienced programer.

The criticisms of it are totally unjustified.

This superb little book is full of little tricks from an obviously experienced Java programmer. The few minor errors that I have found in it do not detract from the overall quality of the work. I have found it most useful.

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.

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.

I havn't actually bought this book, but I was doing a web search the other day for information on Soft and Weak References, and it just so happens that there is a sidebar in the online Chapter 4 that "explains" how they work which I found. Unfortunately the explanation of Reference objects is _completely_ wrong, the author obviously has no idea how Reference objects work. Given such a shoddy effort in this case, I certainly would doubt the accuracy of the rest of the book.