Java Application Performance Tuning and Memory Management

Course Curriculum

Chapter 1: Chapter 1 – Introduction

Lecture 1: What do we mean by performance, and what versions of Java does this course cover

Lecture 2: Example code provided with this course

Lecture 3: Using different JDK and JVM vendors

Lecture 4: The structure of this course

Lecture 5: How to get support while you're taking this course

Chapter 2: Chapter 2 – Just In Time Compilation and the Code Cache

Lecture 1: What is bytecode?

Lecture 2: The concept of "Just In Time Compilation"

Lecture 3: Introducing the first example project

Lecture 4: Finding out which methods are being compiled in our applications

Lecture 5: The C1 and C2 Compilers and logging the compilation activity

Lecture 6: Tuning the code cache size

Lecture 7: Remotely monitoring the code cache with JConsole

Chapter 3: Chapter 3 – Selecting the JVM

Lecture 1: The differences between the 32 bit and 64 bit JVM

Lecture 2: Specifying which compiler to use at runtime

Lecture 3: Turning off tiered compilation

Lecture 4: Tuning native compilation within the Virtual Machine

Chapter 4: Chapter 4 – How memory works – the stack and the heap

Lecture 1: Introduction – the structure of Java's memory

Lecture 2: How the stack works

Lecture 3: How the heap works

Lecture 4: The heap and the stack together – an example

Chapter 5: Chapter 5 – Passing objects between methods

Lecture 1: What does "passing by value" mean?

Lecture 2: What does "passing by reference" mean?

Lecture 3: Passing objects into methods

Lecture 4: The final keyword and why it's not the same as a constant

Lecture 5: Why the final keyword doesn't stop an object's values from being changed

Chapter 6: Chapter 6 – Memory exercise 1

Lecture 1: Instructions for the exercise

Lecture 2: Walkthrough of the solution

Chapter 7: Chapter 7 – Escaping References

Lecture 1: Introduction – what is an escaping reference?

Lecture 2: Strategy 1 – using an iterator

Lecture 3: Strategy 2 – duplicating collections

Lecture 4: Strategy 3 – using immutable collections

Lecture 5: Strategy 4 – duplicating objects

Lecture 6: Strategy 5 – using interfaces to create immutable objects

Lecture 7: Strategy 6 – using modules to hide the implementation

Chapter 8: Chapter 8 – Memory Exercise 2

Lecture 1: Instructions for the exercise

Lecture 2: Walkthrough of the solution

Chapter 9: Chapter 9 – The Metaspace and internal JVM memory optimisations

Lecture 1: The role of the Metaspace

Lecture 2: The PermGen

Lecture 3: Are objects always created on the heap?

Lecture 4: The String Pool

Lecture 5: Interning Strings

Chapter 10: Chapter 10 – Tuning the JVM's Memory Settings

Lecture 1: How the string pool is implemented

Lecture 2: Understanding the size and density of the string pool

Lecture 3: Tuning the size of the string pool

Lecture 4: Tuning the size of the heap

Lecture 5: Shortcut syntax for heap tuning flags

Chapter 11: Chapter 11 – Introducing Garbage Collection

Lecture 1: What it means when we say Java is a managed language

Lecture 2: How Java knows which objects can be removed from the Heap

Lecture 3: The System.gc() method

Lecture 4: Java 11's garbage collector can give unused memory back to the operating system

Lecture 5: Why it's not a good idea to run the System.gc() method

Lecture 6: The finalize() method

Lecture 7: The danger of using finalize()

Chapter 12: Chapter 12 – Monitoring the Heap

Lecture 1: What is a soft leak?

Lecture 2: Introducing (J)VisualVM

Lecture 3: Monitoring the size of the heap over time

Lecture 4: Fixing the problem and checking the heap size

Chapter 13: Chapter 13 – Analysing a heap dump

Lecture 1: Generating a heap dump

Lecture 2: Viewing a heap dump

Chapter 14: Chapter 14 – Generational Garbage Collection

Lecture 1: How the garbage collector works out what is garbage

Lecture 2: Why the heap is divided into generations

Lecture 3: The Internals of the Young Generation

Lecture 4: Viewing the generations in VisualVM

Lecture 5: Viewing the heap when there's a soft leak

Chapter 15: Chapter 15 – Garbage Collector tuning & selection

Lecture 1: Monitoring garbage collections

Lecture 2: Turning off automated heap allocation sizing

Lecture 3: Tuning garbage collection – old and young allocation

Lecture 4: Tuning garbage collection – survivor space allocation

Lecture 5: Tuning garbage collection – generations needed to become old

Lecture 6: Selecting a garbage collector

Lecture 7: The G1 garbage collector

Lecture 8: Tuning the G1 garbage collector

Lecture 9: String de-duplication

Chapter 16: Chapter 16 – Using a profiler to analyse application performance

Lecture 1: Introducing Java Mission Control (JMC)

Lecture 2: Building the JMC binaries

Lecture 3: Running JMC and connecting to a VM

Lecture 4: Customising the overview tab

Lecture 5: The MBean Browser tab

Lecture 6: The System, Memory and Diagnostic Commands tabs

Lecture 7: Introducing our problem project

Lecture 8: Using the flight recorder

Lecture 9: Analyzing a flight recording

Lecture 10: Improving our application

Chapter 17: Chapter 17 – Assessing Performance