Java Multithreading and Parallel Programming Masterclass

本课程是您需要精通线程并将多线程技术正确应用于您的应用程序的最佳在线资源，以便利用您机器的 CPU 功能并最大限度地提高应用程序吞吐量。

本课程的目标是让您深入理解多线程概念（可以在许多其他语言中重用），在 Java 中应用和举例说明，Java 是许多大公司和全球超过 900 万开发人员使用的语言。

我为什么建这个课程？

多线程对于任何开发人员来说都是一个高级主题。我看到很多人都在努力理解这样的事情：

如何加快此代码的运行时间？

是否可以将这个问题拆分为多个独立的部分？

如何衡量此代码的性能？

为什么我的多线程代码卡住了？我该如何调试它？

即使我在这方面有足够的大学背景，我也很难理解其中的一些东西。

但幸运的是，经过多年的线程工作、多次尝试和错误、多次分析会议以及阅读的书籍和文章，我成功地深入理解了这些关键概念并在我的日常工作中正确使用它们。

出于这些原因，我认为建立一门课程来展示我对多线程的理解，肯定会帮助其他人节省时间并避免陷入我所经历的相同陷阱。

内容课程详情：

本课程分为多个章节，每个章节都揭示了多线程中的一个主要主题：

第 1 章 – 一般多线程概念

在本章中，我们将学习多线程的基础知识——线程、进程、并发、并行。本章充满了视觉讲座，旨在提供独特的学习体验。

第 2 章 – 线程管理

这是我们将学习如何创建线程、如何使用线程组、守护线程，以及如何构建异常控制流以避免因未处理的异常而导致崩溃的第一章实践章节。

第 3 章 – 线程同步 – 第 1 部分

本章讨论使用多线程时的主要挑战，即线程同步，以便我们获得应用程序的可预测输出并避免不一致的行为。

我们将学习基本的同步工具——锁、等待集和通知、读写锁和信号量

第 4 章 – 线程同步 – 第 2 部分

本章是上一章的延续，我们将在本章中讨论高级同步工具，如 Barriers 和 Phasers，但我们还将通过使用 volatile 关键字来了解死锁和缓存一致性强制。

第 5 章 – 线程可重用性

我们不能在我们的应用程序中创建无限数量的线程，因为每个线程都需要一些资源才能创建，因此我们需要重用线程。

本章描述了我们在 Java 中处理线程可重用性（线程池）的工具，并深入探讨了如何使用它们、管理性能、选择正确的参数（调优）等。

第 6 章 – 并行算法

在本章中，我们将了解如何通过多线程改进一些已知算法的运行时间。

我们将学习将问题分解成可以并行处理的多个部分，最后合并结果以获得主要输出的思维过程。

第 7 章 – 著名的多线程问题

多线程的第一步已经在多年前完成，当时著名的计算机科学家已经解决了 Java 线程 API 中已知部分的问题。

在本章中，我们将研究其中的几个问题并了解其解决方案的思考过程。这个练习非常有价值，有助于全面理解并行性和同步性。

第 8 章 – 现实世界中的多线程

本课程的最后一章讨论了多线程与广泛使用的框架（如 Spring-Boot、JavaRx 和 JavaFX）之间的联系。我们将看到如何在 Spring Boot 中设计 REST API，它利用多线程以异步方式处理请求。

我们将了解如何使用 JavaRx2 构建并行数据流，以及如何将 UI 更新与 JavaFx 中的后台处理分离，这在技术上适用于移动和桌面应用程序。

MP4 | Video: h264, 1280×720 | Audio: AAC, 44100 Hz
Language: English | Size: 3.99 GB | Duration: 9h 8m

Requirements
Basic Java OOP knowledge (classes, interfaces, methods)
Java 15 (JDK) installed
Intellij Idea Community Edition (preferable), or any other Java IDE installed
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 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.

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!

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