Synopses & Reviews
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
- Identify bottlenecks 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
Includes bibliographical references (p. 533-536) and index.
About the Author
Jack Shirazi is an independent consultant. He was an early adopter of Java, and for the last few years has consulted mainly for the financial sector, focusing on Java performance. Before using Java, Jack spent many years tuning Smalltalk applications. Jack's early career involved research in theoretical physics and bioinformatics. Jack has publications in the field of protein structure and is proud to have contributed to some of the core Perl5 modules.
Table of Contents
Copyright; Preface; Contents of This Book; New in the Second Edition; Virtual Machine (VM) Versions; Conventions Used in This Book; Comments and Questions; Acknowledgments; Chapter 1: Introduction; 1.1 Why Is It Slow?; 1.2 The Tuning Game; 1.3 System Limitations and What to Tune; 1.4 A Tuning Strategy; 1.5 Perceived Performance; 1.6 Starting to Tune; 1.7 What to Measure; 1.8 Don't Tune What You Don't Need to Tune; 1.9 Performance Checklist; Chapter 2: Profiling Tools; 2.1 Measurements and Timings; 2.2 Garbage Collection; 2.3 Method Calls; 2.4 Object-Creation Profiling; 2.5 Monitoring Gross Memory Usage; 2.6 Client/Server Communications; 2.7 Performance Checklist; Chapter 3: Underlying JDK Improvements; 3.1 Garbage Collection; 3.2 Tuning the Heap; 3.3 Gross Tuning; 3.4 Fine-Tuning the Heap; 3.5 Sharing Memory; 3.6 Replacing JDK Classes; 3.7 Faster VMs; 3.8 Better Optimizing Compilers; 3.9 Sun's Compiler and Runtime Optimizations; 3.10 Compile to Native Machine Code; 3.11 Native Method Calls; 3.12 Uncompressed ZIP/JAR Files; 3.13 Performance Checklist; Chapter 4: Object Creation; 4.1 Object-Creation Statistics; 4.2 Object Reuse; 4.3 Reference Objects; 4.4 Avoiding Garbage Collection; 4.5 Initialization; 4.6 Early and Late Initialization; 4.7 Performance Checklist; Chapter 5: Strings; 5.1 The Performance Effects of Strings; 5.2 Compile-Time Versus Runtime Resolution of Strings; 5.3 Conversions to Strings; 5.4 Strings Versus char Arrays; 5.5 String Comparisons and Searches; 5.6 Sorting Internationalized Strings; 5.7 Performance Checklist; Chapter 6: Exceptions, Assertions, Casts, and Variables; 6.1 Exceptions; 6.2 Assertions; 6.3 Casts; 6.4 Variables; 6.5 Method Parameters; 6.6 Performance Checklist; Chapter 7: Loops, Switches, and Recursion; 7.1 Loops; 7.2 Tuning a Loop; 7.3 Exception-Terminated Loops; 7.4 Switches; 7.5 Recursion; 7.6 Recursion and Stacks; 7.7 Performance Checklist; Chapter 8: I/O, Logging, and Console Output; 8.1 Replacing System.out; 8.2 Logging; 8.3 From Raw I/O to Smokin' I/O; 8.4 Serialization; 8.5 Clustering Objects and Counting I/O Operations; 8.6 Compression; 8.7 NIO; 8.8 Performance Checklist; Chapter 9: Sorting; 9.1 Avoiding Unnecessary Sorting Overhead; 9.2 An Efficient Sorting Framework; 9.3 Better Than O(nlogn) Sorting; 9.4 Performance Checklist; Chapter 10: Threading; 10.1 User-Interface Thread and Other Threads; 10.2 Race Conditions; 10.3 Deadlocks; 10.4 Synchronization Overhead; 10.5 Timing Multithreaded Tests; 10.6 Atomic Access and Assignment; 10.7 Thread Pools; 10.8 Load Balancing; 10.9 Threaded Problem-Solving Strategies; 10.10 Performance Checklist; Chapter 11: Appropriate Data Structures and Algorithms; 11.1 Collections; 11.2 Java 2 Collections; 11.3 Hashtables and HashMaps; 11.4 Optimizing Queries; 11.5 Comparing LinkedLists and ArrayLists; 11.6 The RandomAccess Interface; 11.7 Cached Access; 11.8 Caching Examples; 11.9 Finding the Index for Partially Matched Strings; 11.10 Search Trees; 11.11 Performance Checklist; Chapter 12: Distributed Computing; 12.1 Tools; 12.2 Message Reduction; 12.3 Comparing Communications Layers; 12.4 Caching; 12.5 Batching I; 12.6 Application Partitioning; 12.7 Batching II; 12.8 Low-Level Communication Optimizations; 12.9 Distributed Garbage Collection; 12.10 Databases; 12.11 Web Services; 12.12 Performance Checklist; Chapter 13: When to Optimize; 13.1 When Not to Optimize; 13.2 Tuning Class Libraries and Beans; 13.3 Analysis; 13.4 Design and Architecture; 13.5 Tuning After Deployment; 13.6 More Factors That Affect Performance; 13.7 Performance Planning; 13.8 Performance Checklist; Chapter 14: Underlying Operating System and Network Improvements; 14.1 Hard Disks; 14.2 CPU; 14.3 RAM; 14.4 Network I/O; 14.5 Performance Checklist; Chapter 15: J2EE Performance Tuning; 15.1 Performance Planning; 15.2 J2EE Monitoring and Profiling Tools; 15.3 Measurements: What, Where, and How; 15.4 Load Testing; 15.5 User Perception; 15.6 Clustering and Load Balancing; 15.7 Tuning JMS; 15.8 Performance Checklist; Chapter 16: Tuning JDBC; 16.1 Measuring JDBC Performance; 16.2 Tuning JDBC; 16.3 Performance Checklist; Chapter 17: Tuning Servlets and JSPs; 17.1 Don't Use SingleThreadModel; 17.2 Efficient Page Creation and Output; 17.3 Body Tags; 17.4 Cache Tags; 17.5 HttpSession; 17.6 Compression; 17.7 More Performance Tips; 17.8 Case Study: Ace's Hardware SPECmine Tool; 17.9 Performance Checklist; Chapter 18: Tuning EJBs; 18.1 Primary Design Guidelines; 18.2 Performance-Optimizing Design Patterns; 18.3 The Application Server; 18.4 More Suggestions for Tuning EJBs; 18.5 Case Study: The Pet Store; 18.6 Case Study: Elite.com; 18.7 Performance Checklist; Chapter 19: Further Resources; 19.1 The Primary Resource; 19.2 Books; 19.3 Magazines; 19.4 URLs; 19.5 Profilers; 19.6 Optimizers; Colophon;