Java Memory Management (Udemy.com)

What Java professionals need to know about memory, garbage collection, tuning the VM, and avoiding memory leaks.

Created by: Matt Greencroft

Produced in 2020

icon
What you will learn

  • The best Java programmers have a deep understanding of how memory works in Java, and use this to influence how they create their code. This course will give you that understanding, together with the tools that you will need to investigate when things go wrong.
  • By the end of this course, you'll understand important concepts like the stack and the heap, limitations of the final keyword, and how garbage collection works.

icon
Quality Score

Content Quality
/
Video Quality
/
Qualified Instructor
/
Course Pace
/
Course Depth & Coverage
/

Overall Score : 86 / 100

icon
Course Description

This is a course for Java professionals (or aspiring Java professionals) who need an in depth understanding of how memory works in Java. In this course you'll learn what kinds of memory leaks are possible in Java, and how to avoid them. In addition I'll show you tools you can use to analyse how your applications are performing, and detect inefficient memory use, such as objects which are taking up too much memory, or problems causing inefficient garbage collection. And we'll see how to fix these.
You don't need to be a Java Expert to do this course, but you should be able to confidently create basic Java code before you start.
Important note about Java Versions: This course is aimed at users of Java 7 and 8. There's a separate course covering more recent versions of Java (8 and 11+) called "Java Application Performance and Memory Management" - this other course includes almost all the content from this course, upgraded for newer versions of Java, together with other topics around application performance. If you are using newer versions of Java you may wish to take the "Java Application Performance and Memory Management" course. Who this course is for:
  • This is an advanced Java course, and is most suitable for Java programmers who have some experience creating real world production software.
  • If you have ever created code that has run out of memory, or suffered from poor performance due to memory usage, then this course will show you how to identify the cause and resolve the problem.

*Some courses are excluded from this sale. Coupon not working? If the link above doesn't drop prices, clear the cookies in your browser and then click this link here.
Also, you may need to apply the coupon code directly on the cart page to get the discount.

Coupon Code

icon
Instructor Details

Matt Greencroft

Having worked for over 20 years as a professional programmer, mainly in banking, Matt now teaches for Virtual Pair Programmers. His specialist areas are JavaEE, Android, Hadoop and NoSQL. Matt's currently working on a Clojure project, which he finds an enjoyable challenge!
Outside of work, Matt enjoys cycling, but prefers going downhill to uphill, and he also plays the piano very badly.
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.

icon
Students also recommend

Free

10.99

Free

icon
Reviews

4.3

50 total reviews

5 star 4 star 3 star 2 star 1 star
% Complete
% Complete
% Complete
% Complete
% Complete

Informative! Descriptions of stack and heap are thorough. Examples range from simple / high level then drill down to more detailed. Useful information about Garbage Collection and what to avoid: gc() and finalize(). I would like to see more discussion on how memory looks with multiple threads (it is mentioned each gets its own stack, but share the heap). More info will help down the road when learning multithreaded programming and race conditions / sharing data. I really liked the tools introduced (JVisualVM and the memory analyzer) and especially how these work together to look at heap dumps and identify code creating memory leaks. I would not say this course makes me an "expert", but it gives me a good overall picture and a working toolkit on which to build. I do admit, I did (could) not run the last example an d just watched the discussion. My problem was I already had Tomcat installed. I am learning and was afraid this course's Tomcat would conflict with mine. I tried to get the sample to modify Catalina.bat and run with my version and got 404 Not Found. Perhaps some comments on whether it is safe to have both versions of Tomcat would be helpful. I am planning to do some more leaning on this and return and complete the example. Thanks for all the effort on this very good course.

The course exceeds my expectation ! The tutor uses simply java code example along with stack/heap diagrams to explain how java memory allocation and garbage collection work. It's easy to understand even for students without computer science background like me. I am really satisfied.

Course is good, But should have added about Java8 as it came long time back.Expected a few more like:Java 8 additionsAs it is all related to memory mgmt, it should have talked more about Heap dump(different ways of collecting), and thread dumps analysis.

Content is good, although its really informative and takes us through memory management quite in detail, I felt that some of the areas could have been more deeply explained.

Great course! I learn a lot on this course! As a college student enhancing knowledge about programming for me this is a good subject to understand and will help you for your future projects. I'm thankful to Mr. Matt the instructor on this course, he is one of the best Udemy instructors guiding you step-by-step with clear presentation and explanation.Thanks!

The knowledge is great, and the examples is simple to understandBut the script "cc" sometimes is not right, we need to update it ?In the beginning, I am bad at English, especially listening.And the script "cc" is too bad. That why now I am good at listening now (not good but enough to understand)I don't know that is a bug or features ?

The course gave me the information I was looking for. As a java developer I knew how to accomplish things in a way that I thought was best. This course has given me some things to consider as I code going forward to make my applications more memory efficient. I hit one snag with the provided tomcat version and the java version i was running on my machine; jdk 1.8.0_144. Running the application with the provided version I got the error "The type java.io.ObjectInputStream cannot be resolved. It is indirectly referenced from required .class files". Going to the tomcat website, downloading the tomcat version 7.0.96, and using that in place of the provided version solved the issue.

Actually I want some more scenarios or examples to analyze memory leaks. More code examples where developers make common mistakes. Otherwise whatever is covered in the course is also valuable.

It could have been better if following topics would have been included1) JVM architecture ( class loader sub-system , Runtime area , Execution engine etc )2) More details explanation on how each GC algo works3) Application profiling and GC dumps on Production , as JDK is usually not installed on Production env .4) More about (in the market) profiling tools

This course is about very basic stuff. Almost any Java book for beginners will have this kind of information. The first half of the course is especially basic and the last half is a bit more interesting, although material is rather simple. The course description should explicitly state that it targets beginners and not Java professionals. Also the first video in Section 7 duplicates all other videos in that section.

Videos are rushed, I just see half complete programs instead of starting them on the screen.

Overall, the course was not bad. However, I think there's some room for improvement:1. Upgrade the course to a more recent version of Java.2. The content in chapter 7 is duplicated.3. Maybe it's because of the topic, but overall I had the feeling that this course was a little bit too "superficial", only touching the surface at times and it was over as soon as it started to get interesting.For example, the most interesting chapter (for me) was "Hunting for a real world memory leak". Actually, I bought this course because we had a *real* real-world memory leak in our company and now I know from experience that a *real* real-world memory leak definitely doesn't look so simple as presented in the demo application. Actually, it's even hard to read and interpret the stacktraces from the thread dump.Moreover, there was a switch from standalone Java applications (as previously used throughout the course) to a Java Web application on an application-server, the introduction of a load testing tool and the interpretation of the heap dump ("we can not really see that it works now because Tomcat uses thread pools") - all this in 24 minutes.Maybe there are also other techniques for detecting memory leaks such as using static code analysis?