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

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

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

A Guide to Follow This Course

A Quick Overview

6 Lessons

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

The Contract

The Foundation & Challenges

Memory Model: Atomics

9 Lessons

All Atomic Operations

Free Atomic Functions

Atomic Operations on std::shared_ptr

Memory Model: Synchronization and Ordering Constraints

9 Lessons

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

Fences as Memory Barriers

The Three Fences

Acquire and Release Fences

Synchronization with Atomic Variables

Synchronization with Fences

Multithreading: Threads

9 Lessons

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

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

Thread Local Data

10.

Multithreading: Condition Variables

2 Lessons

Condition Variables

The Caveats of Condition Variables

11.

Multithreading: Tasks

11 Lessons

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

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

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

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

Execution Policies

Parallel & Vectorized Execution

Algorithms

The New Algorithms

New Algorithms - A Functional Perspective

16.

The Future: C++20

11 Lessons

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

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

General

Memory Model

Multithreading: Threads

Multithreading: Shared Data

Multithreading: Condition Variables

19.

The Time Library

7 Lessons

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

Glossary

Running Source Code on your own machine

21.

About the Author

1 Lessons

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

intermediate

6 hours

Course

Competitive Programming - Crack Your Coding Interview, C++

intermediate

15 hours

Course

Operating Systems: Virtualization, Concurrency & Persistence