Skip to main content
grasp.study
About
Explore
Pricing
Log in
Try it for free
Back to course
👋
Welcome to a Grasp lesson
Create a free account
to keep studying and create your own study path.
C++ internals for software engineer role
·
Module 8
Advanced C++ Concurrency
1
Atomicity with `std::atomic`
Implement lock-free operations using `std::atomic` and explain the concept of atomicity.
2
Understanding Memory Orderings and Performance
Analyze different memory ordering options (`relaxed`, `acquire-release`, `seq_cst`) and their performance implications.
3
Cache Line Alignment for False Sharing Mitigation
Identify and mitigate false sharing by analyzing cache line behavior in multi-core systems.
4
Asynchronous Data Transfer with `std::promise` and `std::future`
Use `std::promise` and `std::future` to transfer data asynchronously between threads.
5
Asynchronous Operations with `std::packaged_task` and `std::async`
Use `std::packaged_task` and `std::async` to simplify the management of asynchronous operations.
6
Reader-Writer Locks with `std::shared_mutex`
Implement a reader-writer lock using `std::shared_mutex` for scenarios with frequent reads and infrequent writes.
7
Understanding `std::promise` and `std::future` Shared State
Analyze the internal mechanics of `std::promise` and `std::future`, including their shared state.
8
Lock-Based vs. Lock-Free Concurrency: Trade-offs
Compare the trade-offs between lock-based and lock-free concurrency.
Previous module
C++ Concurrency Fundamentals
Next module
Essential C++ Design Patterns