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

Chapter 11. Database Performance Best Practices

This chapter investigates the performance of Java-driven database applications. Applications that access a database are subject to non-Java performance issues: if a database is I/O-bound, or if it is executing SQL queries that require full table scans because an index is missing, no amount of Java tuning or application coding is going to solve the performance issues. When dealing with database technologies, be prepared to learn (from another source) about how to tune and program the database.

This is not to say that the performance of an application that uses a database is insensitive to things under the control of the JVM and the Java technologies that are used. Rather, for good performance it is necessary to ensure that both the database and the application are correctly tuned and executing the best possible code.

The examples in this chapter use a sample database set up to store the data for 128 stock entities for the period of one year. During the year, there are 261 business days.

Prices for the individual stocks are held in a table called STOCKPRICE, which has a primary key of the stock symbol and the date. There are 33,408 rows in that table (128*261).

Each stock has a set of five associated options, which are also priced daily. The STOCKOPTIONPRICE table holds that data with a primary key of the symbol, the date, and an integer representing the option number. There are 167,040 rows in that table (128*261*5).