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

ebook

Autor: Scott Oaks
ISBN: 978-14-920-5606-5
stron: 450, Format: ebook
Data wydania: 2020-02-11
Księgarnia: Helion

Cena książki: 186,15 zł (poprzednio: 216,45 zł)
Oszczędzasz: 14% (-30,30 zł)

Osoby, które kupiły tę książkę, wybierały także »

Coding and testing are generally considered separate areas of expertise. In this practical book, Java expert Scott Oaks takes the approach that anyone who works with Java should be adept at understanding how code behaves in the Java Virtual Machine—including the tunings likely to help performance. This updated second edition helps you gain in-depth knowledge of Java application performance using both the JVM and the Java platform.

Developers and performance engineers alike will learn a variety of features, tools, and processes for improving the way the Java 8 and 11 LTS releases perform. While the emphasis is on production-supported releases and features, this book also features previews of exciting new technologies such as ahead-of-time compilation and experimental garbage collections.

Understand how various Java platforms and compilers affect performance
Learn how Java garbage collection works
Apply four principles to obtain best results from performance testing
Use the JDK and other tools to learn how a Java application is performing
Minimize the garbage collector’s impact through tuning and programming practices
Tackle performance issues in Java APIs
Improve Java-driven database application performance

Osoby które kupowały "Java Performance. In-Depth Advice for Tuning and Programming Java 8, 11, and Beyond. 2nd Edition", wybierały także:

Windows Media Center. Domowe centrum rozrywki 66,67 zł, (8,00 zł -88%)
Ruby on Rails. Ćwiczenia 18,75 zł, (3,00 zł -84%)
DevOps w praktyce. Kurs video. Jenkins, Ansible, Terraform i Docker 190,00 zł, (39,90 zł -79%)
Przywództwo w świecie VUCA. Jak być skutecznym liderem w niepewnym środowisku 58,64 zł, (12,90 zł -78%)
Scrum. O zwinnym zarządzaniu projektami. Wydanie II rozszerzone 58,64 zł, (12,90 zł -78%)

Spis treści

Java Performance. In-Depth Advice for Tuning and Programming Java 8, 11, and Beyond. 2nd Edition eBook -- spis treści

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