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 10
Concurrency and Architectural Patterns
1
Implementing Thread-Safe Classes with the Monitor Object Pattern
Implement the Monitor Object pattern to create a thread-safe class by encapsulating data and synchronization logic.
2
Thread Pool Pattern: Managing Worker Threads
Analyze the Thread Pool pattern as a strategy for managing worker threads and decoupling task submission from execution.
3
Active Object for Concurrent Decoupling
Implement the Active Object pattern to decouple method invocation from method execution for improved concurrency.
4
Thread-Specific Storage Pattern: Managing Per-Thread Data
Explain the Thread-Specific Storage pattern and its use cases for managing per-thread data.
5
Concurrent Event Handling with Leader/Followers
Analyze the Leader/Followers pattern as an efficient model for handling concurrent events from multiple sources.
6
Asynchronous Approaches: Callbacks, Futures, and Message Passing
Compare different approaches to asynchronous task execution: callbacks, futures, and message passing.
7
Building an Event Loop
Implement a simple event loop to process tasks or I/O events from a queue.
8
Combining Patterns for Architectural Solutions
Analyze the composition of multiple patterns to solve a larger architectural problem (e.g., combining Command and Active Object).
Previous module
Essential C++ Design Patterns
Next module
Project: Building a C++ Thread Pool - Core Implementation