In this course we’ll understand what can cause performance issues in our applications, and how to resolve them. This includes a review of some of the options available to us as developers at design-time – how to make good coding choices for optimal performance. For example, when should you pick an ArrayList over a LinkedList? How much difference does the StringBuilder really make? Is Lambda syntax more or less efficient at certain operations? We’ll also learn about various ways that we can configure the virtual machine to provide better performance at run-time, with a range of runtime arguments. We’ll also be diving deep into how the virtual machine manages memory, and how the garbage collection process works and impacts on application performance.
Along the way we’ll be learning about the Just In Time compiler, performance testing and benchmarking, decompiling bytecode, using the GraalVM as an alternative virtual machine and more.
About Java Versions: This is the second iteration of this course and it is designed for all the current versions of Java that have long term support (Java 8 , Java 11 and Java 17). You can follow along with any of these versions. You can also use either the Oracle or the OpenJDK JVMs. For developers using other JVM languages (such as Kotlin, Scala and Groovy) all of the JVM configuration parts of this course will still be relevant, and some of the coding choices may be useful to consider also. (Note that there’s even a review of whether Kotlin provides better or worse performance than Java!)
-
6
What is bytecode? -
7
The concept of "Just In Time Compilation"
-
8
Introducing the first example project
-
9
Finding out which methods are being compiled in our applications
-
10
The C1 and C2 Compilers and logging the compilation activity
-
11
Tuning the code cache size
-
12
Remotely monitoring the code cache with JConsole
-
28
Introduction - what is an escaping reference?
-
29
Strategy 1 - using an iterator
-
30
Strategy 2 - duplicating collections
-
31
Strategy 3 - using immutable collections
-
32
Strategy 4 - duplicating objects
-
33
Strategy 5 - using interfaces to create immutable objects
-
34
Strategy 6 - using modules to hide the implementation
-
47
What it means when we say Java is a managed language
-
48
How Java knows which objects can be removed from the Heap
-
49
The System.gc() method
-
50
Java 11's garbage collector can give unused memory back to the operating system
-
51
Why it's not a good idea to run the System.gc() method
-
52
The finalize() method
-
53
The danger of using finalize()
-
65
Monitoring garbage collections
-
66
Turning off automated heap allocation sizing
-
67
Tuning garbage collection - old and young allocation
-
68
Tuning garbage collection - survivor space allocation
-
69
Tuning garbage collection - generations needed to become old
-
70
Selecting a garbage collector
-
71
The G1 garbage collector
-
72
Tuning the G1 garbage collector
-
73
String de-duplication
-
74
Introducing Java Mission Control (JMC)
-
75
Building the JMC binaries
-
76
Running JMC and connecting to a VM
-
77
Customising the overview tab
-
78
The MBean Browser tab
-
79
The System, Memory and Diagnostic Commands tabs
-
80
Introducing our problem project
-
81
Using the flight recorder
-
82
Analyzing a flight recording
-
83
Improving our application
Lessons:
