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

Chapter 4. Working with the JIT Compiler

The just-in-time (JIT) compiler is the heart of the Java Virtual Machine; nothing controls the performance of your application more than the JIT compiler.

This chapter covers the compiler in depth. It starts with information on how the compiler works and discusses the advantages and disadvantages of using a JIT compiler. Until JDK 8 came along, you had to choose between two Java compilers. Today, those two compilers still exist but work in concert with each other, though in rare cases choosing one is necessary. Finally, we’ll look at some intermediate and advanced tunings of the compiler. If an application is running slowly without any obvious reason, those sections can help you determine whether the compiler is at fault.

Just-in-Time Compilers: An Overview

We’ll start with some introductory material; feel free to skip ahead if you understand the basics of just-in-time compilation.

Computers—and more specifically CPUs—can execute only a relatively few, specific instructions, which are called machine code. All programs that the CPU executes must therefore be translated into these instructions.

Languages like C++ and Fortran are called compiled languages because their programs are delivered as binary (compiled) code: the program is written, and then a static compiler produces a binary. The assembly code in that binary is targeted to a particular CPU. Complementary CPUs can execute the same binary: for example, AMD and Intel CPUs share a ...