Java Performance Tuning (2nd Edition)

Features

• Cover Type: Paperback with 600 pages
• Published by: O'Reilly Media, Inc.
• Edition: 2nd Edition January 2003
• Written in: English
• ISBN 10 Number: 0596003773
• ISBN 13 Number: 978-0596003777
• Book Dimensions: 9.1 x 7.1 x 1.4 inches
• Weighs: 2.2 pounds

Product Description
Performance has been an important issue for Java developers ever since the first version hit the streets. Over the years, Java performance has improved dramatically, but tuning is essential to get the best results, especially for J2EE applications. You can never have code that runs too fast.

"Java Peformance Tuning," 2nd edition provides a comprehensive and indispensable guide to eliminating all types of performance problems. Using many real-life examples to work through the tuning process in detail, JPT shows how tricks such as minimizing object creation and replacing strings with arrays can really pay off in improving your code's performance.

Tuning J2EE applications bears many similarities to tuning J2SE apps, but important and specific considerations apply. For this reason, "Java Performance Tuning," Second Edition includes four new chapters: a new chapter on J2EE application tuning in general followed by chapters on tuning JDBC, servlets and JSPs, and EJBs.

"Java Performance Tuning" offers common-sense advice about what to tune and what to leave alone, emphasizing techniques that provide big performance gains with minimal code restructuring. It gives you crucial guidance that helps you tune without destroying your program's architecture. Blindly changing things in an effort to make a program run faster is a great way to create buggy, unmaintainable code. "Java Performance Tuning" teaches you to work efficiently and effectively, resulting in code that is robust, maintainable, and fast.

"Java Performance Tuning," Second Edition shows you how to:

Create a performance plan

Glean information about your program's behavior from profiling tools

Identifybottlenecks before tuning

Minimize the number of objects your program creates, particularly critical for J2EE applications

Optimize the use of strings

Avoid performance penalties from inefficient code

Improve the behavior of loops and switches

Optimize I/O behavior

Use appropriate algorithms for sorting and other common tasks

Use threads effectively

Optimize the performance of distributed systems

Speed up servlets and JSPs

Structure JDBC usage efficiently

Use effective design patterns to optimize EJB performance

Covers JDK 1.4

Book Info
A complete guide to eliminating Java performance problems, showing the reader how to create a tuning strategy, optimize the use of strings, avoid performance penalties, use threads effectively, improve the behavior of loops and switches, and a host of other tuning techniques. Softcover. DLC: Java (Computer program language). --This text refers to an out of print or unavailable edition of this title.

Reader Reviews
This review is from: Java Performance Tuning (Paperback) 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.