book

Java Performance Tuning, 2nd Edition

Name: Java Performance Tuning, 2nd Edition
Author: Jack Shirazi
ISBN: 9780596003777

by Jack Shirazi

January 2003

Intermediate to advanced

588 pages

18h 3m

English

O'Reilly Media, Inc.

Read now

Unlock full access

A Note Regarding Supplemental Files
Copyright
Preface
Contents of This BookNew in the Second EditionVirtual Machine (VM) VersionsConventions Used in This BookComments and QuestionsAcknowledgments
1. Introduction
1.1. Why Is It Slow?1.2. The Tuning Game1.3. System Limitations and What to Tune1.4. A Tuning Strategy1.5. Perceived Performance1.5.1. Threading to Appear Quicker1.5.2. Streaming to Appear Quicker1.5.3. Caching to Appear Quicker1.6. Starting to Tune1.6.1. User Agreements1.6.2. Setting Benchmarks1.6.3. The Benchmark Harness1.6.4. Taking Measurements1.7. What to Measure1.8. Don’t Tune What You Don’t Need to Tune1.9. Performance Checklist
2. Profiling Tools
2.1. Measurements and Timings2.2. Garbage Collection2.2.1. Using -verbosegc to Analyze Garbage Collection2.2.2. Tools for Analyzing -verbosegc Output2.3. Method Calls2.3.1. Profiling Methodology2.3.2. Java 2 cpu=samples Profile Output2.3.3. HotSpot and 1.3 -Xprof Profile Output2.3.4. JDK 1.1.x -prof and Java 2 cpu=old Profile Output2.3.5. Java 2 -Xhprof Option2.3.6. Java 2 -Xaprof option2.4. Object-Creation Profiling2.5. Monitoring Gross Memory Usage2.6. Client/Server Communications2.6.1. Replacing Sockets2.7. Performance Checklist
3. Underlying JDK Improvements
3.1. Garbage Collection3.2. Tuning the Heap3.3. Gross Tuning3.3.1. Problems with a Larger Heap3.3.2. Starting Versus Maximum Heap Size3.3.3. Benchmarking Considerations3.4. Fine-Tuning the Heap3.4.1. Expanding the Heap3.4.2. Minimizing Pauses3.4.2.1. Incremental or “train” GC3.4.2.2. Concurrent GC3.4.2.3. Enlarge the “new” space3.4.3. Disabling System.gc( ) Calls3.4.4. Tuning RMI Garbage Collection3.4.5. Extreme Heap and Intimate Shared Memory3.4.6. Loading a Huge Number of Classes3.4.7. Per-Thread Stack Size3.4.8. Eliminate Finalizers3.5. Sharing Memory3.6. Replacing JDK Classes3.7. Faster VMs3.7.1. VM Speed Variations3.7.2. VMs with JIT Compilers3.7.3. VM Startup Time3.7.4. Other VM Optimizations3.8. Better Optimizing Compilers3.8.1. What Optimizing Compilers Cannot Do3.8.2. What Optimizing Compilers Can Do3.8.2.1. Remove unused methods and classes3.8.2.2. Increase statically bound calls3.8.2.3. Cut dead code and unnecessary instructions, including checks for null3.8.2.4. Use computationally cheaper alternatives (strength reduction)3.8.2.5. Replace runtime computations with compiled results3.8.2.6. Remove unused fields3.8.2.7. Remove unnecessary parts of compiled files3.8.2.8. Reduce necessary parts of compiled files3.8.2.9. Alter access control to speed up invocations3.8.2.10. Inline calls3.8.2.11. Remove dynamic type checks3.8.2.12. Unroll loops3.8.2.13. Code motion3.8.2.14. Eliminate common subexpressions3.8.2.15. Eliminate unnecessary assignments3.8.2.16. Rename classes, fields, and methods3.8.2.17. Reorder or change bytecodes3.8.2.18. Generate information to help a VM3.8.3. Managing Compilers3.9. Sun’s Compiler and Runtime Optimizations3.9.1. Optimizations You Get for Free3.9.1.1. Literal constants are folded3.9.1.2. String concatenation is sometimes folded3.9.1.3. Constant fields are inlined3.9.1.4. Dead code branches are eliminated3.9.2. Optimizations Performed When Using the -O Option3.9.3. Performance Effects From Runtime Options3.10. Compile to Native Machine Code3.11. Native Method Calls3.12. Uncompressed ZIP/JAR Files3.13. Performance Checklist
4. Object Creation
4.1. Object-Creation Statistics4.2. Object Reuse4.2.1. Pool Management4.2.2. ThreadLocals4.2.3. Reusable Parameters4.2.4. Canonicalizing Objects4.2.4.1. String canonicalization4.2.4.2. Changeable objects4.2.4.3. Weak references4.2.4.4. Enumerating constants4.3. Reference Objects4.3.1. Reference Types4.3.2. SoftReference Flushing4.3.3. The WeakHashMap Class4.3.3.1. How WeakHashMap works4.3.3.2. Some consequences of the WeakHashMap implementation4.4. Avoiding Garbage Collection4.5. Initialization4.6. Early and Late Initialization4.6.1. Preallocating Objects4.6.2. Lazy Initialization4.7. Performance Checklist
5. Strings
5.1. The Performance Effects of Strings5.2. Compile-Time Versus Runtime Resolution of Strings5.3. Conversions to Strings5.3.1. Converting longs to Strings5.3.2. Converting ints to Strings5.3.3. Converting bytes, shorts, chars, and booleans to Strings5.3.4. Converting floats to Strings5.3.5. Converting doubles to Strings5.3.6. Converting Objects to Strings5.4. Strings Versus char Arrays5.4.1. Word-Counting Example5.4.2. Line Filter Example5.4.3. Line Filtering with Regular Expressions5.5. String Comparisons and Searches5.6. Sorting Internationalized Strings5.7. Performance Checklist
6. Exceptions, Assertions, Casts, and Variables
6.1. Exceptions6.1.1. The Cost of try-catch Blocks Without an Exception6.1.2. The Cost of try-catch Blocks with an Exception6.1.3. Using Exceptions Without the Stack Trace Overhead6.1.4. Conditional Error Checking6.2. Assertions6.2.1. Assertion Overhead6.3. Casts6.4. Variables6.5. Method Parameters6.6. Performance Checklist
7. Loops, Switches, and Recursion
7.1. Loops7.1.1. Move Code Out of the Loop7.1.2. Use Temporary Variables7.1.3. Don’t Terminate Loops with Method Calls7.1.4. Use int for Index Variables7.1.5. Use System.arraycopy( )7.1.6. Use Efficient Comparisons7.1.7. Put the Most Common Case First7.1.8. Avoid Reflection7.2. Tuning a Loop7.3. Exception-Terminated Loops7.4. Switches7.5. Recursion7.6. Recursion and Stacks7.7. Performance Checklist

8. I/O, Logging, and Console Output
8.1. Replacing System.out8.2. Logging8.3. From Raw I/O to Smokin’ I/O8.4. Serialization8.5. Clustering Objects and Counting I/O Operations8.6. Compression8.7. NIO8.7.1. Connecting Client Sockets8.7.2. Nondirect Buffers: Fast Casts for Primitive Arrays8.7.3. Direct Buffers: Optimized I/O Operations8.7.4. Multiplexing8.8. Performance Checklist
9. Sorting
9.1. Avoiding Unnecessary Sorting Overhead9.2. An Efficient Sorting Framework9.3. Better Than O(nlogn) Sorting9.4. Performance Checklist
10. Threading
10.1. User-Interface Thread and Other Threads10.2. Race Conditions10.3. Deadlocks10.4. Synchronization Overhead10.4.1. Desynchronization and Synchronized Wrappers10.4.2. Avoiding Serialized Execution10.5. Timing Multithreaded Tests10.6. Atomic Access and Assignment10.7. Thread Pools10.8. Load Balancing10.8.1. Free Load Balancing from TCP/IP10.8.2. Load-Balancing Classes10.8.3. A Load-Balancing Example10.9. Threaded Problem-Solving Strategies10.10. Performance Checklist
11. Appropriate Data Structures and Algorithms
11.1. Collections11.2. Java 2 Collections11.3. Hashtables and HashMaps11.4. Optimizing Queries11.4.1. The Query Problem11.4.1.1. Applying the Boolean-OR operator optimization11.4.1.2. Eliminating the unnecessarily repeated method call11.4.1.3. Eliminating casts and extra access calls11.4.1.4. Avoiding synchronization11.4.1.5. Avoiding the method accessor11.4.1.6. Tighter typing of the collection elements11.4.1.7. Optimizing map queries11.5. Comparing LinkedLists and ArrayLists11.5.1. The Vector and ArrayList Implementations11.5.2. The LinkedList Implementation11.5.3. Performance Tests11.5.4. Querying Performance11.6. The RandomAccess Interface11.6.1. What Does RandomAccess Mean?11.6.2. How Is RandomAccess Used?11.6.3. Speedup from RandomAccess11.6.4. Forward and Backward Compatibility11.7. Cached Access11.8. Caching Examples11.9. Finding the Index for Partially Matched Strings11.10. Search Trees11.11. Performance Checklist
12. Distributed Computing
12.1. Tools12.2. Message Reduction12.2.1. CORBA Example12.2.2. RMI Example12.2.3. Proprietary Communications Layer12.3. Comparing Communications Layers12.4. Caching12.5. Batching I12.6. Application Partitioning12.7. Batching II12.8. Low-Level Communication Optimizations12.8.1. Compression12.8.2. Caching12.8.3. Transfer Batching12.8.4. Multiplexing12.9. Distributed Garbage Collection12.10. Databases12.11. Web Services12.11.1. Measuring Web Services Performance12.11.1.1. Measuring server-side method execution time12.11.1.2. Measuring the full round-trip time12.11.1.3. Inferring round-trip overhead12.11.1.4. Inferring network communication time12.11.1.5. Inferring DNS lookup time12.11.1.6. Inferring marshalling time12.11.2. High-Performance Web Services12.11.2.1. Service granularity12.11.2.2. Load balancing12.11.2.3. Asynchronous processing12.12. Performance Checklist
13. When to Optimize
13.1. When Not to Optimize13.2. Tuning Class Libraries and Beans13.3. Analysis13.4. Design and Architecture13.4.1. Shared Resources13.4.1.1. Transactions13.4.1.2. Locking13.4.1.3. Parallelism13.4.1.4. Data parallelism13.4.2. Scaling13.4.3. Distributed Applications13.4.4. Object Design13.4.5. Techniques for Predicting Performance13.4.5.1. Factor in comparative performance of operations13.4.5.2. Consider the relative costs of different types of accesses and updates13.4.5.3. Use simulations and benchmarks13.4.5.4. Consider the total work done and the design overhead13.4.5.5. Focus on shared resources13.4.5.6. Predict the effects of parallelism13.4.5.7. Assess the costs of data conversions13.4.5.8. Determine whether batch processing is faster13.5. Tuning After Deployment13.6. More Factors That Affect Performance13.6.1. User Interface Usability13.6.2. Training13.6.3. Server Downtime13.7. Performance Planning13.8. Performance Checklist
14. Underlying Operating System and Network Improvements
14.1. Hard Disks14.1.1. Disk I/O14.1.2. Clustering Files14.1.3. Cached Filesystems (RAM Disks, tmpfs, cachefs)14.1.4. Disk Fragmentation14.1.5. Disk Sweet Spots14.2. CPU14.2.1. CPU Load14.2.2. Process Priorities14.3. RAM14.4. Network I/O14.4.1. Latency14.4.2. TCP/IP Stacks14.4.3. Network Bottlenecks14.4.4. DNS Lookups14.5. Performance Checklist
15. J2EE Performance Tuning
15.1. Performance Planning15.2. J2EE Monitoring and Profiling Tools15.2.1. Features to Look For15.2.2. J2EE Monitoring Tools15.3. Measurements: What, Where, and How15.3.1. An Instructive Analysis15.3.2. Suggested Measurements15.3.3. Symptoms of Performance Problems15.3.4. Useful Statistics to Analyze from Measurements15.4. Load Testing15.5. User Perception15.5.1. Screen Navigation15.5.2. Page Display15.5.3. Priority Service15.5.4. Internet Congestion15.5.5. Communication Failures15.5.6. Good Peak Performance15.5.7. Cumulative Delay and User Impatience15.5.8. User Bandwidth15.6. Clustering and Load Balancing15.6.1. Load-Balancing Mechanisms15.6.1.1. DNS load balancing15.6.1.2. Hardware load balancer15.6.1.3. Load-balancing dispatcher/Proxy load balancing15.6.1.4. URL-based load balancing15.6.1.5. Server-pooled objects15.6.1.6. Client-based load balancing15.6.1.7. Application configuration load balancing15.6.1.8. Database partitioning15.6.2. Load-Balancing Algorithms15.7. Tuning JMS15.8. Performance Checklist
16. Tuning JDBC
16.1. Measuring JDBC Performance16.1.1. The Core java.sql Interfaces16.1.2. Wrapping Classes Using Proxy Objects16.1.2.1. Wrapping the Connection class16.1.2.2. Wrapping the Statement classes16.1.2.3. Wrapping the ResultSet class16.1.2.4. The JDBC wrapper framework16.1.2.5. Using the JDBC wrapper framework16.2. Tuning JDBC16.2.1. JDBC Drivers16.2.1.1. Type 1: JDBC-bridging driver16.2.1.2. Type 2: Native API, part-Java driver16.2.1.3. Type 3: Pure Java driver for database middleware16.2.1.4. Type 4: Pure Java driver direct to a database16.2.2. Connection Pooling16.2.3. Optimizing SQL16.2.4. Set-Based Processing16.2.5. Database Server-Side Processing16.2.6. Minimizing Transferred Data16.2.7. Caching16.2.8. Prepared Statements16.2.9. Batching16.2.9.1. Batching accesses by optimizing row fetching16.2.9.2. Batching updates16.2.10. Data Structures16.2.11. Minimizing Data-Conversion Overhead16.2.12. Metadata16.2.13. Handling Exceptions16.2.14. Stored Procedures16.2.15. Transaction Optimization16.2.15.1. Auto-commit mode16.2.15.2. Transaction levels16.2.15.3. User-controlled transactions16.2.15.4. Savepoints and distributed transactions16.2.16. Database Location16.3. Performance Checklist
17. Tuning Servlets and JSPs
17.1. Don’t Use SingleThreadModel17.2. Efficient Page Creation and Output17.2.1. Minimize Output and Logging17.2.2. Use Strings Efficiently17.2.3. Use Bytes Versus Chars17.2.4. Use Network Buffers Efficiently17.2.5. Display Static Pages Quickly17.2.6. Optimize Data Conversions17.2.7. Use ServletOutputStream Directly (Servlets Only)17.2.8. Optimize Partial Page Display17.3. Body Tags17.3.1. Use Include Directive, Not Action17.3.2. Minimize Scope of useBean Action17.3.3. Minimize Custom Tags17.3.4. Use Redirects Versus Forwards17.4. Cache Tags17.5. HttpSession17.5.1. Timing Out Sessions17.5.2. HttpSession Versus Stateful Session Beans17.5.3. HttpSession Serialization17.5.4. Distributing Sessions for Higher Scalability17.5.5. Efficient Resource Management17.6. Compression17.7. More Performance Tips17.8. Case Study: Ace’s Hardware SPECmine Tool17.9. Performance Checklist
18. Tuning EJBs
18.1. Primary Design Guidelines18.1.1. Coarse-Grained EJBs Are Faster18.1.2. EJBs Are Not Data Wrappers18.1.3. Read-Only Data Is Different18.1.4. Stateless Session Beans Are Faster18.1.5. Cache JNDI Lookups18.1.6. CMP or BMP?18.1.7. EJB Transactions18.2. Performance-Optimizing Design Patterns18.2.1. Reducing the Number of Network Trips: The Value Object Pattern18.2.2. Optimizing Database Access: The Data Access Object Pattern and the Fast Lane Reader Pattern18.2.3. Efficiently Transferring Large Datasets: The Page-by-Page Iterator Pattern and the ValueListHandler Pattern18.2.4. Caching Services: The Service Locator, Verified Service Locator, and EJBHomeFactory Patterns18.2.5. Combining EJBs: The Session Façade and CompositeEntity Patterns18.2.6. Reusing Objects: The Factory and Builder Patterns18.2.7. Reducing Locking Conflicts: The Optimistic Locking Pattern18.2.8. Load Balancing: The Reactor and Front Controller Patterns18.2.9. Optimized Message Handling: The Proxy and Decorator Patterns18.2.10. Optimizing CPU Usage: The Message Façade Pattern18.3. The Application Server18.3.1. Security Layer18.3.2. Gross Configuration18.3.3. Tuning Application Servers18.4. More Suggestions for Tuning EJBs18.5. Case Study: The Pet Store18.6. Case Study: Elite.com18.7. Performance Checklist
19. Further Resources
19.1. The Primary Resource19.2. Books19.3. Magazines19.4. URLs19.5. Profilers19.6. Optimizers
About the Author
Colophon
Copyright

Overview

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

Covers JDK 1.4

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 0596003773Errata Page

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills