HomeCoursesModern C++ Concurrency: Get the most out of any machine

Advanced

14h

Updated 5 months ago

Modern C++ Concurrency: Get the most out of any machine
Save

Explore modern C++ concurrency, from C++11 to C++20, combining theory with practice. Gain insights into parallel algorithms, co-routines, and best practices through interactive examples and real-world scenarios.

Join 2.7 million developers at

Overview

Content

Reviews

"Concurrency with Modern C++" is a journey through the present and upcoming concurrency features in C++. - C++11 and C++14 have the basic building blocks for creating concurrent and parallel programs. - With C++17 we have the parallel algorithms from the Standard Template Library (STL). That means that most STL based algorithms can be executed sequentially, parallel, or vectorized. - The concurrency story in C++ goes on. With C++20 we can hope for extended futures, co-routines, transactions, and more. In addition to explaining the details of concurrency in modern C++, this course gives you many interactive code examples; therefore, you can combine theory with practice to get the most out of it. Apart from theory, this course contains a lot of real-world scenarios and use-cases along with pitfalls and how to overcome them using best practices.

"Concurrency with Modern C++" is a journey through the present and upcoming concurrency features in C++. - C++11 and C++14 hav...Show More

Content

140 Lessons

Introduction

1 Lessons

Get familiar with Modern C++ concurrency concepts through practical and theoretical examples.

A Guide to Follow This Course

A Quick Overview

6 Lessons

Look at C++ concurrency evolution, covering C++11 to C++20, practical multithreading, and challenges.

C++11 and C++14: The Foundation

Multithreading in C++

Case Studies

C++17: Parallel Algorithms of the Standard Template Library

C++20: The Concurrent Future

Challenging Issues in C++

Memory Model: The Contract

2 Lessons

Break apart the crucial aspects of the C++ memory model and its challenges.

The Contract

The Foundation & Challenges

Memory Model: Atomics

9 Lessons

Grasp the fundamentals of C++ atomic operations, memory models, and thread synchronization techniques.

All Atomic Operations

Free Atomic Functions

Atomic Operations on std::shared_ptr

Memory Model: Synchronization and Ordering Constraints

9 Lessons

Dig deeper into C++'s memory model for synchronization, ordering constraints, and atomic operations.

Introduction

Types of Synchronization & Ordering Constraints

Sequential Consistency

Acquire Release Semantic

Is the Acquire-Release Semantic Transitive?

Acquire Release: The Typical Misunderstanding

std::mem_order_consume

Data dependencies with std::memory_order_consume

Relaxed Semantic

Memory Model: Fences

5 Lessons

Tackle memory fences to ensure proper synchronization and prevent unintended operation reordering.

Fences as Memory Barriers

The Three Fences

Acquire and Release Fences

Synchronization with Atomic Variables

Synchronization with Fences

Multithreading: Threads

9 Lessons

Build on managing threads and synchronization in C++ to ensure safe concurrency.

Introduction to Threads

Creation of Threads

Managing Thread Lifetime

Thread Lifetime Management: Warnings and Tips

Passing Arguments to Threads

Arguments of Threads: Undefined behavior

Arguments of Threads - Race Conditions and Locks

Methods of Threads

Methods of Threads in Practice

Multithreading: Shared Data

12 Lessons

Step through managing shared data with mutexes, locks, and thread-safe initialization in multithreading.

Introduction to Shared Data

Introduction to Mutexes

Mutex Types and Locking Methods

Issues of Mutexes: Deadlocks

Issues of Mutexes: Avoiding Exceptions

Types of Locks: std::lock_guard

Types of Locks: std::unique_lock

Types of Locks: std::shared_lock

Thread-Safe Initialization

Thread-Safe Initialization: Constant Expressions

Thread-Safe Initialization: call_once and once_flag

Thread-Safe Initialization - Static Variables with Block Scope

Multithreading: Local Data

1 Lessons

Get started with thread-local data for isolated, race-free multithreaded programs.

Thread Local Data

10.

Multithreading: Condition Variables

2 Lessons

Go hands-on with condition variables for effective thread synchronization and avoid common issues.

Condition Variables

The Caveats of Condition Variables

11.

Multithreading: Tasks

11 Lessons

Grasp the fundamentals of utilizing tasks, promises, and futures for efficient multithreaded programming in C++.

Introduction to Tasks

Threads vs Tasks

Introduction to std::async

async: Start Policy

async: Fire and Forget

async: Concurrent Calculation

Introduction to std::packaged_task

Introduction to Promises and Futures

Promise and Future : Return an Exception

Promise and Future: Return a Notification

Introduction to std::shared_future

12.

Case Study: Calculate Sum of a Vector

15 Lessons

Explore efficient vector summation methods, including single-threaded and multithreaded approaches with locks, atomics, and tasks.

Introduction

Single Threaded Summation: Ranged Based for Loops

Single Threaded Summation: Addition with std::accumulate

Single Threaded Summation: Protection with Locks

Single Threaded Summation: Protection with Atomics

Multithreaded Summation: Using std::lock_guard

Multithreaded Summation: Using Atomic Variable

Multithreaded Summation: Using fetch_add Method

Multithreaded Summation: Using fetch_add Method with Relaxed Semantic

Thread Local Summation: Using Local Variable

Thread Local Summation: Using an Atomic Variable with Sequential Consistency

Thread Local Summation: Using an Atomic Variable with Relaxed Semantic

Thread Local Summation: Using Thread Local Data

Thread Local Summation: Using Tasks

Calculate Sum of a Vector: Conclusion

13.

Case Study: Thread-Safe Initialization of a Singleton

9 Lessons

Follow the process of implementing thread-safe singleton patterns, focusing on Meyers Singleton.

Introduction

Double-Checked Locking Pattern

Performance Measurement

Classical Meyers Singleton

Introduction to Thread-Safe Meyers Singleton

Thread-Safe Singleton: std::lock_guard

Thread-Safe Singleton: std::call_once with std::once_flag

Thread-Safe Singleton: Atomics

Conclusion

14.

Case Study: Ongoing Optimization with CppMem

9 Lessons

Practice using CppMem for understanding C++ concurrency, memory behavior, and optimizing programs.

Introduction to CppMem

CppMem: An Overview

CppMem: Non-Atomic Variables

CppMem: Locks

CppMem: Atomics with Sequential Consistency

CppMem: Atomics with an Acquire-Release Semantic

CppMem: Atomics with Non-Atomics

CppMem: Atomics with a Relaxed Semantic

Conclusion

15.

Parallel Algorithms of the Standard Template Library

5 Lessons

Break down STL's parallel algorithms, execution policies, and functional programming in C++.

Execution Policies

Parallel & Vectorized Execution

Algorithms

The New Algorithms

New Algorithms - A Functional Perspective

16.

The Future: C++20

11 Lessons

Walk through new C++20 features for concurrency, including atomic smart pointers, extended futures, transactional memory, and coroutines.

Atomic Smart Pointers

Thread-Safe Linked List Using Atomic Pointers

Introduction to Extended Futures

Attaching Extended Futures

Creating New Futures

Latches and Barriers

Transactional Memory - An Overview

The Two Flavors of Transactional Memory

Introduction to Coroutines

Coroutines: More Details

Task Blocks

17.

Coding Examples

9 Lessons

Go hands-on with concurrency examples to understand and resolve common issues.

ABA

Blocking Issues

Breaking of Program Invariants

Data Races

False Sharing

Lifetime Issues of Variables

Moving Threads

Deadlocks

Race Conditions

18.

Best Practices

5 Lessons

Enhance your skills in minimizing data sharing, effective memory models, and thread safety.

General

Memory Model

Multithreading: Threads

Multithreading: Shared Data

Multithreading: Condition Variables

19.

The Time Library

7 Lessons

Take a closer look at time points, durations, clocks, and time management in C++ multithreading.

The Interplay of Time Point, Time Duration, and Clock

Time Point

From Time Point to Calendar Time

Time Duration

Time Duration Calculations

Clocks

Sleep and Wait

20.

Glossary

2 Lessons

Focus on understanding key C++ concurrency terms, coding, and execution environments.

Glossary

Running Source Code on your own machine

21.

About the Author

1 Lessons

Approach the author's extensive industry experience and contributions to modern programming.

Personal Notes

Certificate of Completion

Showcase your accomplishment by sharing your certificate of completion.

Course Author:

Rainer Grimm

Developed by MAANG Engineers

Every Educative resource is designed by our in-house team of ex-MAANG software engineers and PhD computer science educators — subject matter experts who’ve shipped production code at scale and taught the theory behind it. The goal is to get you hands-on with the skills you need to stay ahead in today's constantly evolving tech landscape. No videos, no fluff — just interactive, project-based learning with personalized feedback that adapts to your goals and experience.

Trusted by 2.7 million developers working at companies

"These are high-quality courses. Trust me. I own around 10 and the price is worth it for the content quality. EducativeInc came at the right time in my career. I'm understanding topics better than with any book or online video tutorial I've done. Truly made for developers. Thanks"

Anthony Walker

@_webarchitect_

"Just finished my first full #ML course: Machine learning for Software Engineers from Educative, Inc. ... Highly recommend!"

Evan Dunbar

ML Engineer

"You guys are the gold standard of crash-courses... Narrow enough that it doesn't need years of study or a full blown book to get the gist, but broad enough that an afternoon of Googling doesn't cut it."

Carlos Matias La Borde

Software Developer

"I spend my days and nights on Educative. It is indispensable. It is such a unique and reader-friendly site"

Souvik Kundu

Front-end Developer

"Your courses are simply awesome, the depth they go into and the breadth of coverage is so good that I don't have to refer to 10 different websites looking for interview topics and content."

Vinay Krishnaiah

Software Developer

"I've tried probably 5-7 different sites and Educative is easily the best. It perfectly blends explanation with interactivity"

Eric Downs

Musician/Entrepeneur

Hands-on Learning Powered by AI

See how Educative uses AI to make your learning more immersive than ever before.

Instant Code Feedback

Evaluate and debug your code with the click of a button. Get real-time feedback on test cases, including time and space complexity of your solutions.

AI Mock Interviews

Test your skills in a simulated interview setting. Receive personalized feedback based on your performance. Available for Coding Interviews, System Design, and more.

Adaptive Learning

At various checkpoints throughout Educative courses, you will be prompted to take a quick assessment. Receive a condensed curriculum tailored to your strengths and skill gaps.

Explain with AI

Select any text within any Educative course, and get an instant explanation — without ever leaving your browser.

AI Code Mentor

AI Code Mentor helps you quickly identify errors in your code, learn from your mistakes, and nudge you in the right direction — just like a 1:1 tutor!

Course

Generic Programming Templates in C++

Explore the power of C++ templates, from function and class basics to advanced features like instantiation and concepts, enhancing code flexibility, reusability, and abstraction without performance loss.

8 h

advanced

Course

Operating Systems: Virtualization, Concurrency & Persistence

Explore operating systems through virtualization, concurrency, and persistence, covering CPU scheduling, process virtualization, locks, semaphores, and hands-on work with I/O devices and file systems.

40 h

intermediate

Course

Mastering Concurrency in Go

Gain insights into implementing concurrency in Go, explore common patterns, and learn to write efficient, practical applications leveraging Go's outstanding support for concurrency.

6 h

intermediate

Course

Competitive Programming - Crack Your Coding Interview, C++

The ultimate guide to coding interviews. Developed by FAANG engineers. Boost problem-solving skills with number theory, dynamic programming, and graph theory. Get interview-ready in just a few hours.

15 h

intermediate

Course

Grokking the Coding Interview Patterns

Master 24 essential coding patterns to solve thousands of LeetCode-style questions. Efficiently prepare for coding interviews with the ultimate course created by FAANG engineers.

85 h

intermediate

Course

Generic Programming Templates in C++

advanced

8 hour

Course

Operating Systems: Virtualization, Concurrency & Persistence

intermediate

40 hour

Course

Mastering Concurrency in Go