Java Application Performance Tuning and Memory Management

Java Application Performance Tuning and Memory Management, available at $94.99, has an average rating of 4.63, with 134 lectures, based on 4341 reviews, and has 35645 subscribers.

You will learn about What can cause performance issues in our applications, and how to resolve them. The choices available to us as developers at design-time – how to make good coding choices for optimal performance. How to configure the virtual machine to provide better performance at run-time. The JVMs Just In Time compiler. How the virtual machine manages memory. Performance testing and benchmarking. This course is ideal for individuals who are Java programmers who are looking to deepen their knowledge of how the Java Virtual Machine works or Application developers who have a problem with a poorly performing application or All java developers who want to be better programmers It is particularly useful for Java programmers who are looking to deepen their knowledge of how the Java Virtual Machine works or Application developers who have a problem with a poorly performing application or All java developers who want to be better programmers.

Enroll now: Java Application Performance Tuning and Memory Management

Summary

Title: Java Application Performance Tuning and Memory Management

Price: $94.99

Average Rating: 4.63

Number of Lectures: 134

Number of Published Lectures: 134

Number of Curriculum Items: 134

Number of Published Curriculum Objects: 134

Original Price: $199.99

Quality Status: approved

Status: Live

What You Will Learn

What can cause performance issues in our applications, and how to resolve them.

The choices available to us as developers at design-time – how to make good coding choices for optimal performance.

How to configure the virtual machine to provide better performance at run-time.

The JVMs Just In Time compiler.

How the virtual machine manages memory.

Performance testing and benchmarking.

Who Should Attend

Java programmers who are looking to deepen their knowledge of how the Java Virtual Machine works

Application developers who have a problem with a poorly performing application

All java developers who want to be better programmers

Target Audiences

Java programmers who are looking to deepen their knowledge of how the Java Virtual Machine works

Application developers who have a problem with a poorly performing application

All java developers who want to be better programmers

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!)

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 youre 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 Javas 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 its not the same as a constant

Lecture 5: Why the final keyword doesnt stop an objects 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 JVMs 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 11s garbage collector can give unused memory back to the operating system

Lecture 5: Why its 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 theres 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

Instructors

Matt Greencroft
Course tutor at Virtual Pair Programmers

Virtual Pair Programmers
Instructor at Udemy

Rating Distribution

1 stars: 26 votes

2 stars: 39 votes

3 stars: 277 votes

4 stars: 1462 votes

5 stars: 2538 votes

Frequently Asked Questions

How long do I have access to the course materials?

You can view and review the lecture materials indefinitely, like an on-demand channel.

Can I take my courses with me wherever I go?

Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don’t have an internet connection, some instructors also let their students download course lectures. That’s up to the instructor though, so make sure you get on their good side!