Modern C++ Multithreading & Lock-Free Programming(C++20/23)

Name: Modern C++ Multithreading & Lock-Free Programming(C++20/23)
Rating: 4.1 (1968 reviews)

Learn C++ multithreading, atomics, thread pools, memory ordering, coroutines, and lock-free systems (C++17/20/23/26)

Created byKasun Liyanage

Last updated 5/2026

English

What you'll learn

Learn Concurrent programming in C++ including feature in C++20/23/26 standards.
You will learn how to implement useful concurrent data structures and algorithms using latest C++ features.
Learn Lock-free programming with C++ atomics and memory ordering mechanisms
Complex industry level use case implementation

Course content

9 sections • 108 lectures • 10h 49m total length

Setting up the environment for the course10:18
Introduction to parallel computing11:34
Quiz : Parallel programming in general1:06
In this quiz we are going to explore parallel programming in general
Uses of parallel programming.
How to launch a thread5:51
Programming exercise 1 : Launching the threads1:01
Joinability of threads4:41
Join and detach functions4:27
How to handle join, in exception scenarios5:51
Programming exercise 2 : Trivial sale a ship model2:06
How to pass parameters to a thread4:15
Problematic situations may arise when passing parameters to a thread3:39
Transferring ownership of a thread3:34
Some useful operations on thread5:35
Programming excersice 3 : Sail a ship with work queues2:00
Parallel accumulate - algorithm explanation3:39
Parallel accumulate algorithm implementation8:30
Thread local storage3:12
Debugging a application in Visual studio12:27
Thread management

introduction to condition variables4:58
Details about condition variables4:26
Thread safe queue implementation : introduction to queue data structure5:20
introduction to futures and async tasks4:36
Thread safe queue implementation : implementation5:39
async tasks detailed discussion5:09
Parallel accumulate algorithm implementation with async task4:05
Introduction to package_task3:46
Communication between threads using std::promises3:14
Retrieving exception using std::futures3:02
std::shared_futures4:18

introduction to lock based thread safe data structures and algorithms4:00
queue data structure implementation using linked list data structure6:19
thread safe queue implementation2:43
Parallel STL introduction10:58
parallel quick sort algorithm implementation11:51
parallel for each implementation7:57
parallel find algorithm implementation with package task6:18
parallel find algorithm implementation with async3:05
Partial sum algorithm introduction7:22
Partial sum algorithm parallel implementation11:03
Introduction to Matrix11:22
Parallel Matrix multiplication4:06
Parallel matrix transpose6:03
Factors affecting the performance of concurrent code10:46

Introduction to atomic operations3:18
Functionality of std::atomic_flag4:07
Functionality of std::atomic_bool6:06
Explanation of compare_exchange functions4:48
atomic pointers6:59
General discussion on atomic types2:07
Important relationships related to atomic operations between threads4:04
Introduction to memory ordering options2:37
Discussion on memory_order_seq_cst5:59
Introduction to instruction reordering4:29
Discussion on memory_order_relaxed4:44
Discussion on memory_order_acquire and memory_order_release4:57
Important aspects of memory_order_acquire and memory_order_release2:20
Concept of transitive synchronization2:49
Discussion on memory_order_consume2:51
Concept of release sequence5:47
Implementation of spin lock mutex4:56
Atomic wait and Notify4:03
Atomic ref4:59
Atomic shared pointer5:36
Lock-Free MPSC Queue6:38

Setting up the environment for CUDA6:10
Elements of CUDA program16:48
Organization of threads in CUDA program 18:38
Organization of threads in CUDA program 26:13
Unique index calculation for threads in a grid9:19
Unique index calculation for threads in a 2D grid5:52
Unique index calculation for threads in a 2D grid 25:09
Timing a CUDA program8:16
CUDA memory transfer11:12
Sum array example9:12
Error handling in a CUDA program4:31
CUDA device properties5:30

Requirements

Basic of c++ programming , some knowledge about data structures and algorithms would be helpful

Description

C++ programming language can be categorized under many topics. Some say its a general purpose programming language, some say its a object oriented version of C. But I liked to categorized it under system programming language. One characteristic of any system programming language including C++ is that language should be able to execute faster compare to other languages like java etc.

C++ paradigm took sharp turn with the introduction of C++11 standards. The most notable difference with previous version is the introduction of new memory model. Memory model is the key part of any language, and the performance of all the functionalities depends on that language memory model. With new c++ memory model, we can exploit tremendous power of modern multi core processors.

Programming a proper C++ code with better memory reclaim mechanism is tough task. But if we want to code thread safe code which can harvest underline processors true power is much more difficult task. In this course we will have in depth discussion on C++ concurrency features including memory model. We will implements thread safe data structures and algorithms, both lock based manner and lock free manner. Proper lock free implementations of data structures and algorithms will provide unprecedented performance output. Let me listed down key aspects we cover in this course below.

1.Basics of C++ concurrency(threads, mutex, package_task, future ,async, promise)

2.Lock based thread safe implementation of data structures and algorithms.

3.C++ memory model.

4.Lock free implementation of data structures and algorithms.

5.C++20 concurrency features.

5. Proper memory reclaim mechanism for lock free data structures.

6. Design aspects of concurrent code.

7. In depth discussion on thread pools.

8. Bonus section on CUDA programming with C and C++.

Who this course is for:

Anyone who wants to widen you skills with c++ programming.

Modern C++ Multithreading & Lock-Free Programming(C++20/23)

What you'll learn

Explore related topics

Course content

Thread management guide18 lectures • 1hr 34min

Thread safe access to shared data and locking mechanisms9 lectures • 42min

Communication between thread using condition variables and futures11 lectures • 49min

Lock based thread safe data structures and algorithm implementation14 lectures • 1hr 44min

C++20 Concurrency features12 lectures • 1hr 10min

C++ memory model and atomic operations21 lectures • 1hr 34min

Lock free data structures and algorithms6 lectures • 58min

Thread pools5 lectures • 42min

Bonus section : Parallel programming in massively parallel devices with CUDA12 lectures • 1hr 37min

Requirements

Description

Who this course is for: