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.
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 optimized 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 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!
Who this course is for:
- Beginner Java Developers who want to enhance their skillset by learning multithreading and parallel programming
- Java Developers who want to learn multithreading the right way, by following a well established step-by-step curriculum
- Any developer with basic Java knowledge, who want to improve the performance of their applications by leveraging parallel programming
- Computer Science / Engineering / PhD Students who want to learn multithreading from the ground.
