Multithreading Programming in C++ Training Course

Concurrency challenges and problems

• Hardware platform limitations - hardware threads, pipes, cache coherence
• Fundamental concepts related to multithreading (correctness of a multithreaded program, liveness, livelock, deadlock, race conditions, atomicity, memory models, Flynn’s taxonomy)
• C++ mechanisms for implementing multithreading and multiprocessing
• Standard library implementation - elements from C++14 to today (C++2a)
• Implementation available in Boost - differences compared to the standard library

Processes and threads

• Multiprocess vs multithreaded applications
• Operating system and threads (short overview of available implementations)
• Process and thread synchronization mechanisms
• Structural implementation of synchronization
• Specifics of multithreading implementation in the object-oriented approach (the role of the RAII pattern)

Memory model in C++

• Objects and memory locations
• Operation serialization and enforcement
• Relations: synchronization, happens-before, ordering of operations for atomic actions, release sequences
• Memory barriers
• Atomic operations

Thread management in C++14 and newer standards

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

Mutual exclusion and critical sections

• Simple principles of mutual exclusion
• Concepts (types) of available locking objects
• Quick introduction to time handling in C++14 (chrono library)
• std::mutex, std::timed_mutex, std::shared_mutex classes and their derivatives
• RAII pattern in lock handling (std::lock_guard, std::unique_lock)
• Dependent and deferred locks (std::lock)
• Lock and thread ownership
• Reader-writer problem
• One-time initialization
• Thread-local (private) memory (std::thread_local)

Thread locks and synchronization

• Semaphore operations
• Recursive locks
• Locks with locking level definition
• Decision variables and cooperation with locks
• Implementation of active and passive barriers (Idle Waits, Busy Waits)
• Resuming thread execution
• Communication between threads (Actor model and CSP)

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
• Utility functions (free) of std::atomic types

Specifics of multithreading API design

• Designing structures using locks - coarse and fine-grained locks
• Performance of concurrent code - estimation and measurement techniques
• Data partitioning
• Scalability of solutions
• Error handling and exceptional situations in application architecture

Testing and debugging multithreaded applications

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

Advanced thread management

• Dependent threads (Saga pattern)
• Avoiding competition in data access
• Controlled stopping and interruption of threads
• Interrupting blocking calls
• Handling interrupts
• Task stealing
• Interrupting tasks during application shutdown

Multithreading design patterns

• Types and purpose of multithreading patterns
• Pattern application scope
• Thread Pool
• Active Object pattern
• Thread-safe queue
• Producer-Consumer pattern
• Monitor pattern
• Multithreading safety of GoF patterns