Java Multithreading and Parallel Programming Masterclass

Learn Multithreading the right way in a complete, step-by-step guide

4.70 (42 reviews)
Udemy
platform
English
language
Software Engineering
category
instructor
580
students
9 hours
content
Jun 2022
last update
$64.99
regular price

What you will learn

Understand why Multithreading is a real advantage for any Java developer

Understand the basic building blocks of multithreaded applications

Understand when Multithreading can speed up the application and when it can't

Understand the Operating System and the hardware implications of a multithreaded application

Be able to see hands-on, relevant examples, deeply explained, for each concept that's being presented

Be able to connect the concepts learned in this course with real-world projects

Description

Intro

This course is the best online resource you need to become proficient in working with threads and correctly apply Multithreading techniques to your applications, in order to leverage the CPU capabilities of your machines and max out the application throughput.

The goal of this course is to make you deeply understand the multithreading concepts (that can be re-used in many other languages), applied and exemplified in Java, the language used by many large companies and more than 9 million developers around the world.

About myself

I wrote my first line of code 10 years ago when I was in highschool. I quickly got addicted by how easy you could build useful programs using C# and Windows Forms.

I followed the Computer Science University track where I managed to set the ground knowledge for anything related to Software Engineering (Algorithms, Data Structures, Operating Systems, Multithreading, Distributed Computing, Networking, and many other topics), and I finalized this amazing 6-year learning path by getting a Master's Degree in Parallel and Distributed Systems where I built from the ground a custom Kubernetes Gang Scheduler optimised for running Spark Jobs.

Currently, I'm a Software Engineer focused on high-scale JVM-based development. I build code used by millions of people around the world.


Why I built this course?

Multithreading is an advanced topic for any developer. I saw many people struggling to understand things like:

  • How can I speed up the runtime of this code?

  • Is it possible to split this problem into multiple independent pieces?

  • How can I measure the performance of this code?

  • Why is my multithreaded code stuck? How can I debug it?

It was really hard for me too to understand some of those things, even if I had enough university background in this area.

But fortunately, after many years of working with threads, many trial and errors, many profiling sessions and books & articles read, I managed to deeply understand those critical concepts and use them properly in my daily job.

For those reasons, I thought that building a course where I expose my understanding on Multithreading, would definitely help other people to save time and avoid going into the same pitfalls that I went through.


This course is going to be continuously updated with new information in the multithreading field, but also with the relevant topics that you request in the Q&A section, so you're buying a true learning asset, since you can use this course as a technical reference.


What is the content course?

This course is split into multiple chapters, each one exposing a major topic in Multithreading:

  • Chapter 1 - General Multithreading Concepts

    • In this chapter we're going to learn the basics of Multithreading - threads, processes, concurrency, parallelism. This chapter is full of visual lectures, designed to provide a unique learning experience.

  • Chapter 2 - Thread Management

    • This is the first hands-on chapter where we're going to learn how to create threads, how to use thread groups, daemon threads, but also how to build exception control flows, to avoid crashes due to unhandled exceptions.

  • Chapter 3 - Thread Synchronization - Part 1

    • This chapter goes into the main challenge when working with multiple threads, which is thread synchronization so that we get a predictable output of our application and avoid inconsistent behaviours.

    • We're going to learn basic synchonization tools - locks, wait sets and notifications, read & write locks and semaphores

  • Chapter 4 - Thread Synchronization - Part 2

    • This chapter is a continuation of the previous one, where we're going to tackle advanced synchronization tools, like Barriers and Phasers, but we're also going to learn about deadlocks and cache coherency enforcement by the use of the volatile keyword.

  • Chapter 5 - Thread Reusability

    • We can't create an infinite number of threads in our applications, because each thread needs some resources in order to be created, so for that reason we need to reuse threads.

    • This chapter describes the tools we have in Java to deal with thread reusability (Thread Pools) and it goes deep into how to work with them, manage performance, choose the right parameters (tuning) and many others.

  • Chapter 6 - Parallel Algorithms

    • In this chapter we're going to see how can we improve the runtime of a couple of known algorithms through multithreading.

    • We're going to learn the thinking process of breaking a problem into multiple pieces which can be processed in parallel, and finally merging the results to get the main output.

  • Chapter 7 - Famous Multithreading Problems

    • The first steps in Multithreading have been done many years ago, where famous computer scientists have tackled the problems which are know part of the Java Threading API.

    • In this chapter, we're going to study a couple of those problems and get the thought process of their solution. This exercise is very valuable and contributes to the overall understanding of parallelism and synchronization.

  • Chapter 8 - Multithreading in Real World

    • This final chapter of this course tackles the connection between Multithreading and widely used frameworks, like Spring-Boot, JavaRx and JavaFX. We're going to see how can we design a REST API in Spring Boot, which processes requests in an asynchronous way, leveraging multithreading.

    • We're going to see how can we build parallel data flows with JavaRx2, and also how to decouple the UI updates from the background processing in JavaFx, which technically applies to mobile and desktop applications.


What are the requirements for this course?

  • Basic Java Knowledge (including Object Orientated Programming)

  • An IDE of your choice, ideally IntelliJ Idea Community Edition, but you can use any IDE where you can run plain Java code

  • Willingness to learn and an open-mind


Thank you for taking the time to look through this description and I'm looking forward to see you in the first lecture!

Content

Introduction

Motivation
How to take the most out of this course
Course Prerequisites & Code Resources

General Multithreading Concepts

What is a Process?
What is a Thread?
Threads vs Processes
Parallel vs Concurrent vs Asynchronous vs Non-Blocking
Amdahl's Law
[Quiz] - General Multithreading Concepts

Thread Management

Thread Creation
Thread Priorities and States
Let's play with Thread Groups
Daemon Threads and User Threads
Thread Exception Handling
Thread Local Variables and Race Conditions
[Project] - Parallel Text File Processing

Thread Synchronization - Part 1

What is Thread Synchronization?
The Synchronized keyword
Wait Sets and Notifications (Producer Consumer)
Understanding Locks with Parallel Vector Sum
What are ReadWrite locks and Spin Locks?
Producer Consumer with Condition Variables
Let's Synchronize Jobs with Semaphores
Can you solve the Race Condition?

Thread Synchronization - Part 2

Parallel Array Search with CountDownLatch
Crushing Matrixes with Barriers
Parallel Array Processing with Phasers
Shift data between threads with Exchangers
What is a Deadlock and how can we avoid it?
The Volatile Keyword
[Project] - Simulating a MapReduce Job with Threads - Part 1
[Project] - Simulating a MapReduce Job with Threads - Part 2
Fan-out values in a set of threads

Thread Reusability

Why we should reuse threads?
Introducing the ThreadPoolExecutor class
Work queues for ThreadPools
Handling exceptions in ThreadPools
Managing rejected tasks in a ThreadPool
Monitoring the Performance of a ThreadPool
Scheduling tasks with ScheduledThreadPoolExecutor
Let's play with ForkJoinPools
Creating Thread Pools with Executors
How to properly size a Thread Pool?

Parallel Algorithms

Bringing parallelism to Quick Sort
Can we improve Binary Search through Multithreading?
Parallel Matrix Multiplication - The naive way
Parallel Matrix Multiplication - The optimal way

Famous Multithreading Problems

Dining Philosophers Problem
Readers-Writers Problem
Sleeping Barber Problem
No-Starve Mutex Problem

Multithreading in Real World

How can we see what's happening inside a JVM?
Introducing Spring Boot Framework (in a nutshell)
Running Asynchronous Workloads on Spring Boot
Introducing RxJava framework (in a nutshell)
Building Parallel Data Pipelines with RxJava2
Unblocking the UI through Multithreading (with JavaFX)

Closing Notes

Links to resources

Screenshots

Java Multithreading and Parallel Programming Masterclass - Screenshot_01Java Multithreading and Parallel Programming Masterclass - Screenshot_02Java Multithreading and Parallel Programming Masterclass - Screenshot_03Java Multithreading and Parallel Programming Masterclass - Screenshot_04

Reviews

Rey
December 3, 2022
Highly recommended. Very professional. Easy to understand lectures and always explain the reasons behind the code.
Helen
February 28, 2022
I really like this class. I have been passionate about multiple threading programming since JDK 1. This class is a good refresher and enhancement for learning the new multiple threading API's. The diagrams, code examples and instructor's explanation are very nice. The instructor usually replies our questions very promptly. I highly recommend this class.
Pkv
February 21, 2022
Amazing course, i don't know why we have less number of students for this course. I really appreciate the instructor's passion is his area of expertise. Good Job!!!
Cristian
April 17, 2021
This course is a great resource if you want to learn multithreading in Java, the curriculum is well structured and the instructor explains each topic really well. Totally recommend!

Charts

Price

Java Multithreading and Parallel Programming Masterclass - Price chart

Rating

Java Multithreading and Parallel Programming Masterclass - Ratings chart

Enrollment distribution

Java Multithreading and Parallel Programming Masterclass - Distribution chart
3424966
udemy ID
8/16/2020
course created date
6/13/2021
course indexed date
Bot
course submited by