Op werkdagen voor 23:00 besteld, morgen in huis Gratis verzending vanaf €20
Wij wijzen u graag op het volgende
Door drukte zijn de levertijden van PostNL aangepast en kan uw pakket vertraging oplopen. Door de Brexit kan de levering van Engelse boeken vertraging oplopen.

Java Performance

In-Depth Advice for Tuning and Programming Java 8, 11, and Beyond

Paperback Engels 2020 9781492056119
Verkooppositie 4479
Op voorraad | Op werkdagen voor 21:00 uur besteld, volgende dag in huis

Samenvatting

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

Specificaties

ISBN13:9781492056119
Taal:Engels
Bindwijze:paperback
Aantal pagina's:408
Uitgever:O'Reilly
Druk:2
Verschijningsdatum:31-3-2020
Hoofdrubriek:IT-management / ICT

Lezersrecensies

Wees de eerste die een lezersrecensie schrijft!

Geef uw waardering

Zeer goed Goed Voldoende Matig Slecht

Over Scott Oaks

Scott Oaks is a Java Technologist at Sun Microsystems, where he has worked since 1987. While at Sun, he has specialized in many disparate technologies, from the SunOS kernel to network programming and RPCs. Since 1995, he's focused primarily on Java and bringing Java technology to end-users. Scott also authored O'Reilly's Java Security, Java Threads and Jini in a Nutshell titles.

Andere boeken door Scott Oaks

Inhoudsopgave

Preface
Who Should (and Shouldn’t) Read This Book
What’s New in the Second Edition
Conventions Used in This Book
Using Code Examples
O’Reilly Online Learning
How to Contact Us
Acknowledgments

1. Introduction
A Brief Outline
Platforms and Conventions
Java Platforms
Hardware Platforms
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
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
Common Code Examples
Summary

3. A Java Performance Toolbox
Operating System Tools and Analysis
CPU Usage
The CPU Run Queue
Disk Usage
Network Usage
Java Monitoring Tools
Basic VM Information
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
Enabling JFR
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
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
Choosing a GC Algorithm
Basic GC Tuning
Sizing the Heap
Sizing the Generations
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
Understanding the CMS Collector
Tuning to Solve Concurrent Mode Failures
Advanced Tunings
Tenuring and Survivor Spaces
Allocating Large Objects
AggressiveHeap
Full Control Over Heap Size
Experimental GC Algorithms
Concurrent Compaction: ZGC and Shenandoah
No Collection: Epsilon GC
Summary

7. Heap Memory Best Practices
Heap Analysis
Heap Histograms
Heap Dumps
Out-of-Memory Errors
Using Less Memory
Reducing Object Size
Using Lazy Initialization
Using Immutable and Canonical Objects
Object Life-Cycle Management
Object Reuse
Soft, Weak, and Other References
Compressed Oops
Summary

8. Native Memory Best Practices
Footprint
Measuring Footprint
Minimizing Footprint
Native Memory Tracking
Shared Library Native Memory
JVM Tunings for the Operating System
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
Avoiding Synchronization
False Sharing
JVM Thread Tunings
Tuning Thread Stack Sizes
Biased Locking
Thread Priorities
Monitoring Threads and Locks
Thread Visibility
Blocked Thread Visibility
Summary

10. Java Servers
Java NIO Overview
Server Containers
Tuning Server Thread Pools
Async Rest Servers
Asynchronous Outbound Calls
Asynchronous HTTP
JSON Processing
An Overview of Parsing and Marshaling
JSON Objects
JSON Parsing
Summary

11. Database Performance Best Practices
Sample Database
JDBC
JDBC Drivers
JDBC Connection Pools
Prepared Statements and Statement Pooling
Transactions
Result Set Processing
JPA
Optimizing JPA Writes
Optimizing JPA Reads
JPA Caching
Spring Data
Summary

12. Java SE API Tips
Strings
Compact Strings
Duplicate Strings and String Interning
String Concatenation
Buffered I/O
Classloading
Class Data Sharing
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

Alle 100 bestsellers

Rubrieken

Populaire producten

    Personen

      Trefwoorden

        Java Performance