Multithreading Fundamentals in C++
Description
This course is oriented to developers who know the C++ programming language yet lack experience of writing concurrent code.
The course focuses on difficulties that arise in writing multithreading programs, particularly concurrent access to shared resources and deadlocks. For classical problems as reader-writer problem, producer-consumer problem, and dining philosophers' problem possible solutions are included.
To solve problems, a wide range of synchronization primitives available in the C++ standard library, are applied, which allows to combine studying fundamental issues with practicing development skills.
Special attention is paid to atomic operations and writing lock-free algorithms. In this regard, we consider the concept of memory model, which is extremely important for ensuring correct operation of concurrent programs and at the same time rather difficult to understand.
The course also covers the performance of multithreading program, and reviews the implementation of a thread pool.This course provides an introduction to multithreding
in C++. It covers the main difficulties of writing concurrent code and basic
synchronization primitives. Special attention is paid to understanding
classical problems of parallel programming, which demonstrate solutions to most
common problems.
is issued on the Luxoft Training form
Objectives
- Understand the main difficulties in developing concurrent code and ways to overcome them;
- Learn how to use classical synchronization primitives and understand their algorithms and internal representation;
- Review solutions to fundamental problems of concurrent programming and find their analogues in real-life problems;
- Understand lock-free algorithms.
Target Audience
Primary:
- Developers having knowledge of C++ and lacking experience in multithreading.
Additional:
- Architects, system designers, developers using other programming languages but willing to understand multithreading programming.
Prerequisites
Ability to understand C++ code.
Roadmap
- [Theory – 0.5h] Threads and processes. Concurrency, parallelism and multithreading
How multitasking is implemented in modern operating systems. What is the difference between parallel and concurrent program execution - [Theory – 0.5h; Practice – 0.5h] Thread creation and interrupting
How to create threads of execution, basic methods of communication between threads - [Theory - 1h] Data races, deadlocks, bottlenecks.
What difficulties usually arise in writing multithreading code, what problems they can lead to - [Theory – 1h; Practice – 0.5h] Synchronization: semaphores, mutexes and conditional variables.
Synchronizing access to shared resources with various synchronization primitives - [Theory – 3h; Practice - 6h] Classical tasks: reader-writer, producer-consumer, dining philosophers
Common tasks of multithreading programming in examples based on classical problems - [Theory – 1h; Practice – 0.5h] Atomic data types, memory model, lock-free algorithms
How to provide synchronization without mutexes. Atomic operations and memory model - [Theory – 0.5h; Practice - 1h] Thread pools.
Multithreading does not always guarantee high performance. In certain cases, additional solutions are required, such as thread pools.
[Theory – 7.5h (47%); Practice – 8.5h (53%)]