Java Application Performance Tuning and Memory Management

Focused View

Matt Greencroft,Virtual Pair Programmers

10:04:34

57 View

01 - Chapter 1 - Introduction

001 What do we mean by performance, and what versions of Java does this course cover.mp4

04:00

002 Example code provided with this course.mp4

01:01

002 PracticalsAndCode.zip

003 Using different JDK and JVM vendors.mp4

01:37

004 The structure of this course.mp4

05:11

005 How to get support while youre taking this course.mp4

01:51

02 - Chapter 2 - Just In Time Compilation and the Code Cache

001 What is bytecode.mp4

03:03

002 The concept of Just In Time Compilation.mp4

05:51

003 Introducing the first example project.mp4

03:35

004 Finding out which methods are being compiled in our applications.mp4

05:23

005 The C1 and C2 Compilers and logging the compilation activity.mp4

04:43

006 Tuning the code cache size.mp4

06:18

007 Remotely monitoring the code cache with JConsole.mp4

08:29

03 - Chapter 3 - Selecting the JVM

001 The differences between the 32 bit and 64 bit JVM.mp4

04:32

002 Specifying which compiler to use at runtime.mp4

06:34

003 Turning off tiered compilation.mp4

02:04

004 Tuning native compilation within the Virtual Machine.mp4

09:58

04 - Chapter 4 - How memory works - the stack and the heap

001 Introduction - the structure of Javas memory.mp4

02:57

002 How the stack works.mp4

05:56

003 How the heap works.mp4

05:25

004 The heap and the stack together - an example.mp4

07:46

05 - Chapter 5 - Passing objects between methods

001 What does passing by value mean.mp4

04:54

002 What does passing by reference mean.mp4

02:20

003 Passing objects into methods.mp4

04:13

004 The final keyword and why its not the same as a constant.mp4

03:09

005 Why the final keyword doesnt stop an objects values from being changed.mp4

05:42

06 - Chapter 6 - Memory exercise 1

001 Instructions for the exercise.mp4

01:35

002 Walkthrough of the solution.mp4

08:46

07 - Chapter 7 - Escaping References

001 Introduction - what is an escaping reference.mp4

05:33

002 Strategy 1 - using an iterator.mp4

07:31

003 Strategy 2 - duplicating collections.mp4

06:54

004 Strategy 3 - using immutable collections.mp4

04:38

005 Strategy 4 - duplicating objects.mp4

05:06

006 Strategy 5 - using interfaces to create immutable objects.mp4

04:39

007 Strategy 6 - using modules to hide the implementation.mp4

09:49

08 - Chapter 8 - Memory Exercise 2

001 Instructions for the exercise.mp4

04:40

002 Walkthrough of the solution.mp4

07:39

09 - Chapter 9 - The Metaspace and internal JVM memory optimisations

001 The role of the Metaspace.mp4

05:09

002 The PermGen.mp4

01:58

003 Are objects always created on the heap.mp4

04:14

004 The String Pool.mp4

06:08

005 Interning Strings.mp4

03:03

10 - Chapter 10 - Tuning the JVMs Memory Settings

001 How the string pool is implemented.mp4

04:10

002 Understanding the size and density of the string pool.mp4

11:36

003 Tuning the size of the string pool.mp4

03:28

004 Tuning the size of the heap.mp4

07:44

005 Shortcut syntax for heap tuning flags.mp4

03:06

11 - Chapter 11 - Introducing Garbage Collection

001 What it means when we say Java is a managed language.mp4

04:57

002 How Java knows which objects can be removed from the Heap.mp4

02:49

003 The System.gc() method.mp4

04:28

004 Java 11s garbage collector can give unused memory back to the operating system.mp4

03:52

005 Why its not a good idea to run the System.gc() method.mp4

02:05

006 The finalize() method.mp4

05:17

007 The danger of using finalize().mp4

03:28

12 - Chapter 12 - Monitoring the Heap

001 What is a soft leak.mp4

08:51

002 Introducing (J)VisualVM.mp4

06:58

003 Monitoring the size of the heap over time.mp4

02:59

004 Fixing the problem and checking the heap size.mp4

04:15

13 - Chapter 13 - Analysing a heap dump

001 Generating a heap dump.mp4

03:13

002 Viewing a heap dump.mp4

05:20

14 - Chapter 14 - Generational Garbage Collection

001 How the garbage collector works out what is garbage.mp4

03:53

002 Why the heap is divided into generations.mp4

04:06

003 The Internals of the Young Generation.mp4

05:00

004 Viewing the generations in VisualVM.mp4

06:10

005 Viewing the heap when theres a soft leak.mp4

03:05

15 - Chapter 15 - Garbage Collector tuning & selection

001 Monitoring garbage collections.mp4

06:28

002 Turning off automated heap allocation sizing.mp4

05:47

003 Tuning garbage collection - old and young allocation.mp4

04:55

004 Tuning garbage collection - survivor space allocation.mp4

02:24

005 Tuning garbage collection - generations needed to become old.mp4

02:06

006 Selecting a garbage collector.mp4

05:37

007 The G1 garbage collector.mp4

04:10

008 Tuning the G1 garbage collector.mp4

01:54

009 String de-duplication.mp4

02:52

16 - Chapter 16 - Using a profiler to analyse application performance

001 Introducing Java Mission Control (JMC).mp4

03:44

002 Building the JMC binaries.mp4

05:16

003 Running JMC and connecting to a VM.mp4

03:30

004 Customising the overview tab.mp4

03:41

005 The MBean Browser tab.mp4

01:40

006 The System, Memory and Diagnostic Commands tabs.mp4

02:24

007 Introducing our problem project.mp4

07:59

008 Using the flight recorder.mp4

09:02

009 Analyzing a flight recording.mp4

04:22

010 Improving our application.mp4

04:39

17 - Chapter 17 - Assessing Performance

001 Why benchmarking isnt straight forward.mp4

06:10

002 Setting up the code for benchmarking.mp4

05:51

003 A simple approach to micro-benchmarking.mp4

01:53

004 Adding in a warm-up period.mp4

04:37

005 Comparing two code alternatives.mp4

02:30

006 Using Macro-bencharmking.mp4

05:10

18 - Chapter 18 - Benchmarking with JMH

001 Installing the JMH benchmarking tool.mp4

04:18

002 Creating and running benchmarks.mp4

05:56

003 Using different benchmark modes.mp4

03:09

19 - Chapter 19 - Performance and Benchmarking Exercise

001 Instructions for exercise 1 (creating a flight recording).mp4

01:40

002 Walkthrough of the solution & setting up ready for the next challenge.mp4

05:12

003 Instructions for exercise 2 (use JMH to macrobenchmark the project).mp4

01:54

004 Walkthrough of the solution - part 1 setting up the code.mp4

05:17

005 Walkthrough of the solution - part 2 - integrating into JMH.mp4

07:09

20 - Chapter 20 - How Lists Work

001 Why its important to understand how the different List implementations work.mp4

01:39

002 The 8 different list implementations.mp4

01:39

003 The CopyOnWriteArrayList.mp4

02:37

004 The ArrayList.mp4

06:02

005 Specifying the initial size of an ArrayList.mp4

05:32

006 The Vector.mp4

02:55

007 The Stack.mp4

01:18

008 The LinkedList.mp4

03:07

009 Choosing the optimal list type.mp4

06:57

010 Sorting lists.mp4

02:37

21 - Chapter 21 - How Maps Work

001 How Hashmaps Work - part 1.mp4

03:17

002 The role of the Hashcode.mp4

01:19

003 How Hashmaps Work - part 2.mp4

03:46

004 Specifying the initial size and factor of a HashMap.mp4

04:30

005 HashMap Performance.mp4

02:31

006 The rules for Hashcodes.mp4

04:15

007 Generating and optimising the Hashcode method.mp4

06:29

008 Optimising Hashmap Performance.mp4

00:49

009 How The LinkedHashMap Works.mp4

04:52

010 The HashTable and TreeMap.mp4

01:50

22 - Chapter 22 - Other Coding Choices

001 Introduction to how well compare coding options.mp4

01:41

002 Comparing primatives with objects.mp4

02:54

003 Comparing BigDecimals with Doubles.mp4

03:46

004 Using the StringBuilder.mp4

04:46

005 Comparing loops and streams.mp4

06:41

006 A note on logging.mp4

03:57

23 - Chapter 23 - GraalVM

001 What is GraalVM.mp4

06:45

002 Installing GraalVM.mp4

02:59

003 Using the Graal Virtual Machine.mp4

06:35

004 Using the Graal Compiler.mp4

02:24

005 Native image building with Graal.mp4

04:14

006 Using the Graal experimental features within OpenJDK.mp4

03:34

24 - Chapter 24 - Using Other JVM Languages

001 The principles of using other JVM Languages.mp4

07:04

002 Looking at bytecode with javap.mp4

10:50

003 Disassembling bytecode back to Java.mp4

07:22

25 - Chapter 25 - Course Summary

001 The OpenJ9 Virtual Machine and whats coming up in future versions of Java.mp4

03:01

002 Bonus lecture.html

Description

Discover how coding choices, benchmarking, performance tuning and memory management can optimize your Java applications

What You'll 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 JVM's Just In Time compiler.
How the virtual machine manages memory.
Performance testing and benchmarking.

Who is this for?

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

What You Need to Know?

Basic working knowledge of Java programming is needed, but you don't need to be a Java expert!

More details

Description
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!)
Who this course is for:
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

User Reviews

Rating

average 0

Total votes0

Focused display

Director of Capability Training and Management Ltd (www.virtualpairprogrammers.com and www.inceptiontraining.co.uk), with responsibility for design and delivery of a range of training courses. In addition, I'm a professional toastmaster and independent celebrant.

Virtual Pair Programmers

Instructor's Courses

Virtual Pair Programmers are here to help you take your programming skills to the next level. We're a group of enthusiastic software trainers who are all professional developers, and have a really practical approach to learning - our courses are full of real world case studies and hands on examples. We teach what you need to know to be productive in the workplace and to get the job done, rather than going through each feature turn by turn.

Udemy

View courses Udemy

Students take courses primarily to improve job-related skills.Some courses generate credit toward technical certification. Udemy has made a special effort to attract corporate trainers seeking to create coursework for employees of their company.