book

Java Performance: The Definitive Guide

by Scott Oaks

April 2014

Intermediate to advanced

423 pages

12h 24m

English

O'Reilly Media, Inc.

Read now

Unlock full access

Who Should (and Shouldn’t) Read This BookConventions Used in This BookUsing Code ExamplesSafari® Books OnlineHow to Contact UsAcknowledgments
A Brief OutlinePlatforms and ConventionsJVM Tuning FlagsThe 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 ApplicationMicrobenchmarksMicrobenchmarks must use their resultsMicrobenchmarks must not include extraneous operationsMicrobenchmarks must measure the correct inputMacrobenchmarksMesobenchmarksCommon Code ExamplesUnderstand Throughput, Batching, and Response TimeElapsed Time (Batch) MeasurementsThroughput MeasurementsResponse Time TestsUnderstand VariabilityTest Early, Test OftenSummary
Operating System Tools and AnalysisCPU UsageJava and single-CPU usageJava and multi-CPU usageThe CPU Run QueueDisk UsageNetwork UsageJava Monitoring ToolsBasic VM InformationWorking with tuning flagsThread InformationClass InformationLive GC AnalysisHeap Dump PostprocessingProfiling ToolsSampling ProfilersInstrumented ProfilersBlocking Methods and Thread TimelinesNative ProfilersJava Mission ControlJava Flight RecorderJFR overviewJFR Memory viewJFR Code viewOverview of JFR eventsEnabling JFREnabling JFR via Java Mission ControlEnabling JFR via the command lineSelecting JFR EventsSummary
Just-in-Time Compilers: An OverviewHot Spot CompilationBasic Tunings: Client or Server (or Both)Optimizing StartupOptimizing Batch OperationsOptimizing Long-Running ApplicationsJava and JIT Compiler VersionsIntermediate Tunings for the CompilerTuning the Code CacheCompilation ThresholdsInspecting the Compilation ProcessAdvanced Compiler TuningsCompilation ThreadsInliningEscape AnalysisDeoptimizationNot Entrant CodeDeoptimizing Zombie CodeTiered Compilation LevelsSummary
Garbage Collection OverviewGenerational Garbage CollectorsGC AlgorithmsThe serial garbage collectorThe throughput collectorThe CMS collectorThe G1 collectorChoosing a GC AlgorithmGC algorithms and batch jobsGC algorithms and throughput testsGC algorithms and response time testsChoosing between CMS and G1Basic GC TuningSizing the HeapSizing the GenerationsSizing Permgen and MetaspaceControlling ParallelismAdaptive SizingGC ToolsSummary
Understanding the Throughput CollectorAdaptive and Static Heap Size TuningUnderstanding the CMS CollectorTuning to Solve Concurrent Mode FailuresRunning the background thread more oftenAdjusting the CMS background threadsTuning CMS for PermgenIncremental CMSUnderstanding the G1 CollectorTuning G1Tuning the G1 background threadsTuning G1 to run more (or less) frequentlyTuning G1 mixed GC cyclesAdvanced TuningsTenuring and Survivor SpacesAllocating Large ObjectsThread-local allocation buffersSizing TLABsHumongous objectsG1 region sizesG1 allocation of humongous objectsAggressiveHeapFull Control Over Heap SizeSummary
Heap AnalysisHeap HistogramsHeap DumpsOut of Memory ErrorsOut of native memoryOut of permgen or metaspace memoryOut of heap memoryGC overhead limit reachedUsing Less MemoryReducing Object SizeLazy InitializationEager deinitializationImmutable and Canonical ObjectsCreating canonical objectsString InterningObject Lifecycle ManagementObject ReuseObject poolsThread-local variablesWeak, Soft, and Other ReferencesSoft referencesWeak referencesFinalizers and final referencesSummary
FootprintMeasuring FootprintMinimizing FootprintNative NIO BuffersNative Memory TrackingNMT over timeJVM Tunings for the Operating SystemLarge PagesLinux huge (large) pagesLinux transparent huge pagesWindows large pagesLarge page sizesCompressed oopsSummary
Thread Pools and ThreadPoolExecutorsSetting the Maximum Number of ThreadsSetting the Minimum Number of ThreadsThread Pool Task SizesSizing a ThreadPoolExecutorThe ForkJoinPoolAutomatic ParallelizationThread SynchronizationCosts of SynchronizationSynchronization and scalabilityCosts of locking objectsAvoiding SynchronizationFalse SharingJVM Thread TuningsTuning Thread Stack SizesBiased LockingLock SpinningThread PrioritiesMonitoring Threads and LocksThread VisibilityBlocked Thread VisibilityBlocked threads and JFRBlocked threads and JStackSummary

Basic Web Container PerformanceHTTP Session StateHTTP session state memoryHighly available HTTP session stateThread PoolsEnterprise Java Session BeansTuning EJB PoolsTuning EJB CachesLocal and Remote InstancesXML and JSON ProcessingData SizeAn Overview of Parsing and MarshallingChoosing a ParserPull parsersPush parsers (SAX)Alternate parsing implementations and parser factoriesXML ValidationDocument ModelsJava Object ModelsObject SerializationTransient FieldsOverriding Default SerializationCompressing Serialized DataKeeping Track of Duplicate ObjectsJava EE Networking APIsSizing Data TransfersSummary
JDBCJDBC DriversWhere work is performedThe JDBC driver typePrepared Statements and Statement PoolingSetting up the statement poolManaging statement poolsJDBC Connection PoolsTransactionsJDBC transaction controlTransaction isolation and lockingResult Set ProcessingJPATransaction HandlingOptimizing JPA WritesOptimizing JPA ReadsReading less dataUsing JOIN in queriesBatching and queriesJPA CachingDefault caching (lazy loading)Caching and eager loadingJoin fetch and cachingAvoiding queriesSizing the JPA cacheJPA Read-Only EntitiesSummary
Buffered I/OClassloadingRandom NumbersJava Native InterfaceExceptionsString PerformanceLoggingJava Collections APISynchronized Versus UnsynchronizedCollection SizingCollections and Memory EfficiencyAggressiveOptsAlternate ImplementationsMiscellaneous FlagsLambdas and Anonymous ClassesLambda and Anonymous ClassloadingStream and Filter PerformanceLazy TraversalSummary

Content preview from Java Performance: The Definitive Guide

Appendix A. Summary of Tuning Flags

Table A-1. Flags to tune the just-in-time compiler

Flag	What it does	When to use it	See also
`-server`	Chooses the server compiler.	For long-running applications that need fast performance.	Hot Spot Compilation
`-client`	Chooses the client compiler.	For applications where startup is the most important factor.	Hot Spot Compilation
`-XX:+TieredCompilation`	Uses tiered compilation (both client and server).	For applications where you want the best possible performance and have enough available native memory for the extra compiled code.	Hot Spot Compilation
`-XX:ReservedCodeCacheSize=``<MB>`	Reserves space for code compiled by the JIT compiler	When you see a warning that you are out of code cache, and generally when using tiered compilation.	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 very uncommon.	Tuning the Code Cache
`-XX:CompileThreshold=``<N>`	Sets the number of times a method or loop is executed before compiling it.	When using the server compiler, this can cause more methods to be compiled, and methods to be compiled sooner. The first case is sometimes an advantage if you aren’t using tiered compilation.	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 as to what the compiler is doing.	Inspecting the Compilation Process ...