Multithreading Programming in C++ Training Course

Concurrency Challenges and Problems

• Hardware platform limitations - hardware threads, pipes, cache coherence
• Basic concepts related to multithreading (correctness of multithreaded programs, liveness, starvation, deadlock, race conditions, atomicity, memory models, Flynn's taxonomy)
• Available C++ mechanisms for implementing multithreading and multiprocessing
• Standard library implementation - elements from C++14 to the present day (C++2a)
• Boost library implementation - differences from the standard library

Processes and Threads

• Multiprocess and multithreaded applications
• Operating system and threads (short overview of available implementations)
• Synchronization mechanisms for processes and threads
• Structural implementation of synchronization
• Specifics of multithreading implementation in object-oriented approaches (role of RAII pattern)

Memory Model in C++

• Objects and memory locations
• Serialization of operations and their enforcement
• Relationships: synchronization, precedence, ordering of operations for atomic actions, release sequences
• Memory barriers
• Atomic operations

Thread Management in C++14 and Newer Standards

• std::thread class and starting threads
• Thread identification
• Joining and detaching threads
• Threads and standard containers
• Exception handling in C++14 threads

Mutual Exclusion and Critical Sections

• Basic principles of mutual exclusion
• Concepts (types) of available blocking objects
• Quick introduction to time handling in C++14 (chrono library)
• std::mutex, std::timed_mutex, std::shared_mutex classes and derivatives
• RAII pattern in lock handling (std::lock_guard, std::unique_lock)
• Deferred and dependent locks (std::lock)
• Lock and thread ownership
• Readers-writers problem
• One-time initialization
• Thread-local (private) memory (std::thread_local)

Thread Synchronization and Locks

• Semaphore operations
• Recursive locks
• Locks with defined lock level
• Decision variables and cooperation with locks
• Implementation of active and passive barriers (Idle Waits, Busy Waits)
• Resuming thread execution
• Inter-thread communication (Actor and CSP models)

Asynchronous Tasks

• Asynchronous events and their handling
• Futures
• Promises
• Packaged tasks

Atomic Types

• Standard atomic types
• Universal atomic flag (std::atomic_flag)
• "std::atomic[T]" class template and its specializations
• Tool functions (free functions) of std::atomic types

Specifics of Multithreaded API Design

• Designing structures using locks - coarse-grained and fine-grained locks
• Concurrency code performance - estimation and measurement techniques
• Data partitioning
• Scalability of solutions
• Error and exception handling in application architecture

Testing and Debugging Multithreaded Applications

• Code reviews for multithreaded operations
• Specifics of testing multithreaded applications
• Unit tests
• Increasing the probability of failure scenarios for testing
• Formal methods for testing multithreaded applications
• Multithreaded application architecture patterns and testing/debugging (overview)

Advanced Thread Management

• Dependent threads (Saga pattern)
• Avoiding data access contention
• Controlled thread stop and interruption
• Interrupting blocking calls
• Interrupt handling
• Task stealing
• Task interruption during application shutdown

Multithreading Design Patterns

• Types and purposes of multithreading patterns
• Scope of pattern application
• Thread Pool
• Active Object pattern
• Thread-Safe Queue
• Producer-Consumer pattern
• Monitor pattern
• Multithreaded safety of GoF patterns