Java Performance. In-Depth Advice for Tuning and Programming Java 8, 11, and Beyond. 2nd Edition

Kup polskie wydanie:

Spis treści ebooka

• Preface
  • Who Should (and Shouldnt) Read This Book
  • Whats New in the Second Edition
  • Conventions Used in This Book
  • Using Code Examples
  • OReilly Online Learning
  • How to Contact Us
  • Acknowledgments
• 1. Introduction
  • A Brief Outline
  • Platforms and Conventions
    • Java Platforms
      • JVM tuning flags
    • Hardware Platforms
      • Multicore hardware
      • Software containers
  • The Complete Performance Story
    • Write Better Algorithms
    • Write Less Code
    • Oh, Go Ahead, Prematurely Optimize
    • Look Elsewhere: The Database Is Always the Bottleneck
    • Optimize for the Common Case
  • Summary
• 2. An Approach to Performance Testing
  • Test a Real Application
    • Microbenchmarks
      • Microbenchmarks must use their results
      • Microbenchmarks must test a range of input
      • Microbenchmarks must measure the correct input
      • Microbenchmark code may behave differently in production
    • Macrobenchmarks
    • Mesobenchmarks
  • Understand Throughput, Batching, and Response Time
    • Elapsed Time (Batch) Measurements
    • Throughput Measurements
    • Response-Time Tests
  • Understand Variability
  • Test Early, Test Often
  • Benchmark Examples
    • Java Microbenchmark Harness
      • JMH and parameters
      • Comparing tests
      • Setup code
      • Controlling execution and repeatability
    • Common Code Examples
  • Summary
• 3. A Java Performance Toolbox
  • Operating System Tools and Analysis
    • CPU Usage
      • Java and single-CPU usage
      • Java and multi-CPU usage
    • The CPU Run Queue
    • Disk Usage
    • Network Usage
  • Java Monitoring Tools
    • Basic VM Information
      • Working with tuning flags
    • Thread Information
    • Class Information
    • Live GC Analysis
    • Heap Dump Postprocessing
  • Profiling Tools
    • Sampling Profilers
    • Instrumented Profilers
    • Blocking Methods and Thread Timelines
    • Native Profilers
  • Java Flight Recorder
    • Java Mission Control
    • JFR Overview
      • JFR Memory view
      • JFR Code view
      • Overview of JFR events
    • Enabling JFR
      • Enabling JFR via Java Mission Control
      • Enabling JFR via the command line
    • Selecting JFR Events
  • Summary
• 4. Working with the JIT Compiler
  • Just-in-Time Compilers: An Overview
    • HotSpot Compilation
  • Tiered Compilation
  • Common Compiler Flags
    • Tuning the Code Cache
    • Inspecting the Compilation Process
    • Tiered Compilation Levels
    • Deoptimization
      • Not entrant code
      • Deoptimizing zombie code
  • Advanced Compiler Flags
    • Compilation Thresholds
    • Compilation Threads
    • Inlining
    • Escape Analysis
    • CPU-Specific Code
  • Tiered Compilation Trade-offs
  • The GraalVM
  • Precompilation
    • Ahead-of-Time Compilation
    • GraalVM Native Compilation
  • Summary
• 5. An Introduction to Garbage Collection
  • Garbage Collection Overview
    • Generational Garbage Collectors
    • GC Algorithms
      • The serial garbage collector
      • The throughput collector
      • The G1 GC collector
      • The CMS collector
      • Experimental collectors
    • Choosing a GC Algorithm
      • When to use (and not use) the serial collector
        • Single hyper-threaded CPU hardware
      • When to use the throughput collector
  • Basic GC Tuning
    • Sizing the Heap
    • Sizing the Generations
      • Adaptive sizing
    • Sizing Metaspace
    • Controlling Parallelism
  • GC Tools
    • Enabling GC Logging in JDK 8
    • Enabling GC Logging in JDK 11
  • Summary
• 6. Garbage Collection Algorithms
  • Understanding the Throughput Collector
    • Adaptive and Static Heap Size Tuning
  • Understanding the G1 Garbage Collector
    • Tuning G1 GC
      • Tuning the G1 background threads
      • Tuning G1 GC to run more (or less) frequently
      • Tuning G1 GC mixed GC cycles
  • Understanding the CMS Collector
    • Tuning to Solve Concurrent Mode Failures
      • Running the background thread more often
      • Adjusting the CMS background threads
  • Advanced Tunings
    • Tenuring and Survivor Spaces
    • Allocating Large Objects
      • Thread-local allocation buffers
      • Sizing TLABs
      • Humongous objects
      • G1 GC region sizes
      • G1 GC allocation of humongous objects
    • AggressiveHeap
    • Full Control Over Heap Size
  • Experimental GC Algorithms
    • Concurrent Compaction: ZGC and Shenandoah
      • Latency effects of concurrent compaction
      • Throughput effects of concurrent compacting collectors
    • No Collection: Epsilon GC
  • Summary
• 7. Heap Memory Best Practices
  • Heap Analysis
    • Heap Histograms
    • Heap Dumps
    • Out-of-Memory Errors
      • Out of native memory
      • Out of metaspace memory
      • Out-of-heap memory
      • GC overhead limit reached
  • Using Less Memory
    • Reducing Object Size
    • Using Lazy Initialization
      • Eager deinitialization
    • Using Immutable and Canonical Objects
      • Creating canonical objects
  • Object Life-Cycle Management
    • Object Reuse
      • Object pools
      • Thread-local variables
    • Soft, Weak, and Other References
      • Soft references
      • Weak references
      • Finalizers and final references
      • Cleaner objects
    • Compressed Oops
  • Summary
• 8. Native Memory Best Practices
  • Footprint
    • Measuring Footprint
    • Minimizing Footprint
    • Native Memory Tracking
      • NMT over time
    • Shared Library Native Memory
      • Native memory and inflaters/deflaters
      • Native NIO buffers
  • JVM Tunings for the Operating System
    • Large Pages
      • Linux huge (large) pages
      • Linux transparent huge pages
      • Windows large pages
  • Summary
• 9. Threading and Synchronization Performance
  • Threading and Hardware
  • Thread Pools and ThreadPoolExecutors
    • Setting the Maximum Number of Threads
    • Setting the Minimum Number of Threads
    • Thread Pool Task Sizes
    • Sizing a ThreadPoolExecutor
  • The ForkJoinPool
    • Work Stealing
    • Automatic Parallelization
  • Thread Synchronization
    • Costs of Synchronization
      • Synchronization and scalability
      • Costs of locking objects
    • Avoiding Synchronization
    • False Sharing
  • JVM Thread Tunings
    • Tuning Thread Stack Sizes
    • Biased Locking
    • Thread Priorities
  • Monitoring Threads and Locks
    • Thread Visibility
    • Blocked Thread Visibility
      • Blocked threads and JFR
      • Blocked threads and JStack
  • Summary
• 10. Java Servers
  • Java NIO Overview
  • Server Containers
    • Tuning Server Thread Pools
    • Async Rest Servers
  • Asynchronous Outbound Calls
    • Asynchronous HTTP
      • Async HTTP clients
      • Async HTTP clients and thread usage
      • Asynchronous database calls
  • JSON Processing
    • An Overview of Parsing and Marshaling
    • JSON Objects
    • JSON Parsing
  • Summary
• 11. Database Performance Best Practices
  • Sample Database
  • JDBC
    • JDBC Drivers
      • Where work is performed
      • The JDBC driver type
    • JDBC Connection Pools
    • Prepared Statements and Statement Pooling
      • Setting up the statement pool
      • Managing statement pools
    • Transactions
      • JDBC transaction control
      • Transaction isolation and locking
    • Result Set Processing
  • JPA
    • Optimizing JPA Writes
    • Optimizing JPA Reads
      • Reading less data
      • Using JOIN in queries
      • Batching and queries
    • JPA Caching
      • Default caching (lazy loading)
      • Caching and eager loading
      • Join fetch and caching
      • Avoiding queries
      • Sizing the JPA cache
  • Spring Data
  • Summary
• 12. Java SE API Tips
  • Strings
    • Compact Strings
    • Duplicate Strings and String Interning
      • String deduplication
      • String interning
      • Custom string interning
    • String Concatenation
  • Buffered I/O
  • Classloading
    • Class Data Sharing
      • Class data sharing benefits
  • Random Numbers
  • Java Native Interface
  • Exceptions
  • Logging
  • Java Collections API
    • Synchronized Versus Unsynchronized
    • Collection Sizing
    • Collections and Memory Efficiency
  • Lambdas and Anonymous Classes
  • Stream and Filter Performance
    • Lazy Traversal
  • Object Serialization
    • Transient Fields
    • Overriding Default Serialization
    • Compressing Serialized Data
    • Keeping Track of Duplicate Objects
  • Summary
• A. Summary of Tuning Flags
• Index

pokaż cały spis treści

ukryj recenzje