Home>Courses>Modern C++ Concurrency: Get the most out of any machine

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

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.

Advanced

140 Lessons

14h

Certificate of Completion

AI-POWERED

Explanations

AI-POWERED

Explanations

This course includes

107 Playgrounds

Course Overview

Course Content

Recommendations

Course Overview

"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. ...Show More

Course Content

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

Course Author

Rainer Grimm

Trusted by 2.5 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-Powered Mock Interviews

Put your skills to the test in a simulated interview setting. Receive personalized feedback based on your performance. Available in Premium & Premium Plus plans.

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!

Recommended before starting this course

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.

intermediate

40 hours

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.

intermediate

6 hours

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.

intermediate

15 hours

Course

Operating Systems: Virtualization, Concurrency & Persistence

intermediate

40 hour

Course

Mastering Concurrency in Go

intermediate

6 hour

Course

Competitive Programming - Crack Your Coding Interview, C++

intermediate

15 hour

Related Courses and Skill Paths

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.

advanced

8 hours

Course

Generic Programming Templates in C++

advanced

8 hour

Free Resources

FOR TEAMS

Interested in this course for your business or team?

Unlock this course (and 1,000+ more) for your entire org with DevPath