AI-powered learning
Save this course
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.
4.5
140 Lessons
14h
Join 2.9 million developers at
Join 2.9 million developers at
Learning Roadmap
2.
A Quick Overview
A Quick Overview
Look at C++ concurrency evolution, covering C++11 to C++20, practical multithreading, and challenges.
3.
Memory Model: The Contract
Memory Model: The Contract
2 Lessons
2 Lessons
Break apart the crucial aspects of the C++ memory model and its challenges.
4.
Memory Model: Atomics
Memory Model: Atomics
9 Lessons
9 Lessons
Grasp the fundamentals of C++ atomic operations, memory models, and thread synchronization techniques.
5.
Memory Model: Synchronization and Ordering Constraints
Memory Model: Synchronization and Ordering Constraints
9 Lessons
9 Lessons
Dig deeper into C++'s memory model for synchronization, ordering constraints, and atomic operations.
6.
Memory Model: Fences
Memory Model: Fences
5 Lessons
5 Lessons
Tackle memory fences to ensure proper synchronization and prevent unintended operation reordering.
7.
Multithreading: Threads
Multithreading: Threads
9 Lessons
9 Lessons
Build on managing threads and synchronization in C++ to ensure safe concurrency.
8.
Multithreading: Shared Data
Multithreading: Shared Data
12 Lessons
12 Lessons
Step through managing shared data with mutexes, locks, and thread-safe initialization in multithreading.
10.
Multithreading: Condition Variables
Multithreading: Condition Variables
2 Lessons
2 Lessons
Go hands-on with condition variables for effective thread synchronization and avoid common issues.
11.
Multithreading: Tasks
Multithreading: Tasks
11 Lessons
11 Lessons
Grasp the fundamentals of utilizing tasks, promises, and futures for efficient multithreaded programming in C++.
12.
Case Study: Calculate Sum of a Vector
Case Study: Calculate Sum of a Vector
15 Lessons
15 Lessons
Explore efficient vector summation methods, including single-threaded and multithreaded approaches with locks, atomics, and tasks.
13.
Case Study: Thread-Safe Initialization of a Singleton
Case Study: Thread-Safe Initialization of a Singleton
9 Lessons
9 Lessons
Follow the process of implementing thread-safe singleton patterns, focusing on Meyers Singleton.
14.
Case Study: Ongoing Optimization with CppMem
Case Study: Ongoing Optimization with CppMem
9 Lessons
9 Lessons
Practice using CppMem for understanding C++ concurrency, memory behavior, and optimizing programs.
15.
Parallel Algorithms of the Standard Template Library
Parallel Algorithms of the Standard Template Library
5 Lessons
5 Lessons
Break down STL's parallel algorithms, execution policies, and functional programming in C++.
16.
The Future: C++20
The Future: C++20
11 Lessons
11 Lessons
Walk through new C++20 features for concurrency, including atomic smart pointers, extended futures, transactional memory, and coroutines.
17.
Coding Examples
Coding Examples
9 Lessons
9 Lessons
Go hands-on with concurrency examples to understand and resolve common issues.
18.
Best Practices
Best Practices
5 Lessons
5 Lessons
Enhance your skills in minimizing data sharing, effective memory models, and thread safety.
19.
The Time Library
The Time Library
7 Lessons
7 Lessons
Take a closer look at time points, durations, clocks, and time management in C++ multithreading.
20.
Glossary
Glossary
2 Lessons
2 Lessons
Focus on understanding key C++ concurrency terms, coding, and execution environments.
Certificate of Completion
Showcase your accomplishment by sharing your certificate of completion.
Complete more lessons to unlock your certificate
Developed by MAANG Engineers
ABOUT THIS COURSE
"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.
ABOUT THE AUTHOR
Rainer Grimm
I’ve worked as a software architect, team lead, and instructor since 1999. I like to write articles on the topics C++, Python, and Haskell in my spare time. I often speak at conferences.
Trusted by 2.9 million developers working at companies
A
Anthony Walker
@_webarchitect_
E
Evan Dunbar
ML Engineer
S
Software Developer
Carlos Matias La Borde
S
Souvik Kundu
Front-end Developer
V
Vinay Krishnaiah
Software Developer
Built for 10x Developers
No Passive Learning
Learn by building with project-based lessons and in-browser code editor
Personalized Roadmaps
The platform adapts to your strengths & skills gaps as you go
Future-proof Your Career
Get hands-on with in-demand skills
AI Code Mentor
Write better code with AI feedback, smart debugging, and "Ask AI"
MAANG+ Interview Prep
AI Mock Interviews simulate every technical loop at top companies
Free Resources
