book

Java Performance, 2nd Edition

by Scott Oaks

February 2020

Intermediate to advanced

448 pages

13h 15m

English

O'Reilly Media, Inc.

Book available

Read now

Unlock full access

Who Should (and Shouldn’t) Read This BookWhat’s New in the Second EditionConventions Used in This BookUsing Code ExamplesO’Reilly Online LearningHow to Contact UsAcknowledgments
A Brief OutlinePlatforms and ConventionsJava PlatformsHardware PlatformsThe Complete Performance StoryWrite Better AlgorithmsWrite Less CodeOh, Go Ahead, Prematurely OptimizeLook Elsewhere: The Database Is Always the BottleneckOptimize for the Common CaseSummary
Test a Real ApplicationMicrobenchmarksMacrobenchmarksMesobenchmarksUnderstand Throughput, Batching, and Response TimeElapsed Time (Batch) MeasurementsThroughput MeasurementsResponse-Time TestsUnderstand VariabilityTest Early, Test OftenBenchmark ExamplesJava Microbenchmark HarnessCommon Code ExamplesSummary
Operating System Tools and AnalysisCPU UsageThe CPU Run QueueDisk UsageNetwork UsageJava Monitoring ToolsBasic VM InformationThread InformationClass InformationLive GC AnalysisHeap Dump PostprocessingProfiling ToolsSampling ProfilersInstrumented ProfilersBlocking Methods and Thread TimelinesNative ProfilersJava Flight RecorderJava Mission ControlJFR OverviewEnabling JFRSelecting JFR EventsSummary
Just-in-Time Compilers: An OverviewHotSpot CompilationTiered CompilationCommon Compiler FlagsTuning the Code CacheInspecting the Compilation ProcessTiered Compilation LevelsDeoptimizationAdvanced Compiler FlagsCompilation ThresholdsCompilation ThreadsInliningEscape AnalysisCPU-Specific CodeTiered Compilation Trade-offsThe GraalVMPrecompilationAhead-of-Time CompilationGraalVM Native CompilationSummary
Garbage Collection OverviewGenerational Garbage CollectorsGC AlgorithmsChoosing a GC AlgorithmBasic GC TuningSizing the HeapSizing the GenerationsSizing MetaspaceControlling ParallelismGC ToolsEnabling GC Logging in JDK 8Enabling GC Logging in JDK 11Summary
Understanding the Throughput CollectorAdaptive and Static Heap Size TuningUnderstanding the G1 Garbage CollectorTuning G1 GCUnderstanding the CMS CollectorTuning to Solve Concurrent Mode FailuresAdvanced TuningsTenuring and Survivor SpacesAllocating Large ObjectsAggressiveHeapFull Control Over Heap SizeExperimental GC AlgorithmsConcurrent Compaction: ZGC and ShenandoahNo Collection: Epsilon GCSummary
Heap AnalysisHeap HistogramsHeap DumpsOut-of-Memory ErrorsUsing Less MemoryReducing Object SizeUsing Lazy InitializationUsing Immutable and Canonical ObjectsObject Life-Cycle ManagementObject ReuseSoft, Weak, and Other ReferencesCompressed OopsSummary
FootprintMeasuring FootprintMinimizing FootprintNative Memory TrackingShared Library Native MemoryJVM Tunings for the Operating SystemLarge PagesSummary
Threading and HardwareThread Pools and ThreadPoolExecutorsSetting the Maximum Number of ThreadsSetting the Minimum Number of ThreadsThread Pool Task SizesSizing a ThreadPoolExecutorThe ForkJoinPoolWork StealingAutomatic ParallelizationThread SynchronizationCosts of SynchronizationAvoiding SynchronizationFalse SharingJVM Thread TuningsTuning Thread Stack SizesBiased LockingThread PrioritiesMonitoring Threads and LocksThread VisibilityBlocked Thread VisibilitySummary

Java NIO OverviewServer ContainersTuning Server Thread PoolsAsync Rest ServersAsynchronous Outbound CallsAsynchronous HTTPJSON ProcessingAn Overview of Parsing and MarshalingJSON ObjectsJSON ParsingSummary
Sample DatabaseJDBCJDBC DriversJDBC Connection PoolsPrepared Statements and Statement PoolingTransactionsResult Set ProcessingJPAOptimizing JPA WritesOptimizing JPA ReadsJPA CachingSpring DataSummary
StringsCompact StringsDuplicate Strings and String InterningString ConcatenationBuffered I/OClassloadingClass Data SharingRandom NumbersJava Native InterfaceExceptionsLoggingJava Collections APISynchronized Versus UnsynchronizedCollection SizingCollections and Memory EfficiencyLambdas and Anonymous ClassesStream and Filter PerformanceLazy TraversalObject SerializationTransient FieldsOverriding Default SerializationCompressing Serialized DataKeeping Track of Duplicate ObjectsSummary

Content preview from Java Performance, 2nd Edition

Appendix. Summary of Tuning Flags

This appendix covers commonly used flags and gives pointers on when to use them. Commonly used here includes flags that were commonly used in previous versions of Java and are no longer recommended; documentation and tips on older versions of Java may recommend those flags, so they are mentioned here.

Table A-1. Flags to tune the just-in-time compiler
Flag	What it does	When to use it	See also
`-server`	This flag no longer has any effect; it is silently ignored.	N/A	“Tiered Compilation”
`-client`	This flag no longer has any effect; it is silently ignored.	N/A	“Tiered Compilation”
`-XX:+TieredCompilation`	Uses tiered compilation.	Always, unless you are severely constrained for memory.	“Tiered Compilation” and “Tiered Compilation Trade-offs”
`-XX:ReservedCodeCacheSize=``<MB>`	Reserves space for code compiled by the JIT compiler.	When running a large program and you see a warning that you are out of code cache.	“Tuning the Code Cache”
`-XX:InitialCodeCacheSize=``<MB>`	Allocates the initial space for code compiled by the JIT compiler.	If you need to preallocate the memory for the code cache (which is uncommon).	“Tuning the Code Cache”
`-XX:CompileThreshold=``<N>`	Sets the number of times a method or loop is executed before compiling it.	This flag is no longer recommended.	“Compilation Thresholds”
`-XX:+PrintCompilation`	Provides a log of operations by the JIT compiler.	When you suspect an important method isn’t being compiled or are generally curious ...