Book Image

Concurrency with Modern C++

By : Rainer Grimm
Book Image

Concurrency with Modern C++

By: Rainer Grimm

Overview of this book

C++11 is the first C++ standard that deals with concurrency. The story goes on with C++17 and will continue with C++20/23. Concurrency with Modern C++ is a practical guide that gets you to grips with concurrent programming in Modern C++. Starting with the C++ memory model and using many ready-to-run code examples, the book covers everything you need to improve your C++ multithreading skills. You'll gain insight into different design patterns. You'll also uncover the general consideration you have to keep in mind while designing a concurrent data structure. The final chapter in the book talks extensively about the common pitfalls of concurrent programming and ways to overcome these hurdles. By the end of the book, you'll have the skills to build your own concurrent programs and enhance your knowledge base.

Related Content you might be interested in

Current Title:

Small book image
Concurrency with Modern C++
Rainer Grimm
Dec, 2019 | 543 pages
Small book image
The C++ Standard Library
Rainer Grimm
Dec, 2019 | 251 pages
Small book image
Mastering C++ Multithreading
Maya Posch
Jul, 2017 | 244 pages
Small book image
C++ High Performance
Bjoumlrn Andrist | Viktor Sehr
Dec, 2020 | 544 pages
Table of Contents (19 chapters)
Free Chapter
1
Reader Testimonials
Reader Testimonials
2
Introduction
Introduction
Conventions
Source Code
How you should read the book?
Personal Notes
3
Concurrency with Modern C++
Concurrency with Modern C++
C++11 and C++14: The Foundation
C++17: Parallel Algorithms of the Standard Template Library
The Near Future: C++20
Case Studies
The Future: C++23
Patterns and Best Practices
Challenges
Time Library
CppMem
Glossary
4
Memory Model
Memory Model
Basics of the Memory Model
The Contract
Atomics
The Class Template std::atomic_ref (C++20)
The Synchronisation and Ordering Constraints
Fences
5
Multithreading
Multithreading
Threads
Shared Data
Thread-Local Data
Condition Variables
Tasks
6
Parallel Algorithms of the Standard Template Library
Parallel Algorithms of the Standard Template Library
Execution Policies
Algorithms
The New Algorithms
Performance
7
The Near Future: C++20
The Near Future: C++20
A Cooperatively Interruptible Joining Thread
Atomic Smart Pointers
Latches and Barriers
Semaphores
Coroutines
8
Case Studies
Case Studies
Calculating the Sum of a Vector
Thread-Safe Initialisation of a Singleton
Ongoing Optimisation with CppMem
Conclusion
9
The Future: C++23
The Future: C++23
Executors
Extended Futures
Transactional Memory
Task Blocks
Data-Parallel Vector Library
10
Patterns and Best Practices
Patterns and Best Practices
History
Invaluable Value
Pattern versus Best Practices
Anti-Pattern
11
Synchronisation Patterns
Synchronisation Patterns
Dealing with Sharing
Dealing with Mutation
12
Concurrent Architecture
Concurrent Architecture
Active Object
Monitor Object
Half-Sync/Half-Async
13
Best Practices
Best Practices
General
Multithreading
Memory Model
14
Lock-Based Data Structures
Lock-Based Data Structures
General Considerations
Concurrent Stack
Concurrent Queue
15
Challenges
Challenges
ABA Problem
Blocking Issues
Breaking of Program Invariants
Data Races
Deadlocks
False Sharing
Lifetime Issues of Variables
Moving Threads
Race Conditions
16
The Time Library
The Time Library
The Interplay of Time Point, Time Duration, and Clock
Time Point
Time Duration
Clocks
Sleep and Wait
17
CppMem - An Overview
CppMem - An Overview
The simplified Overview
18
Glossary
Glossary
ACID
CAS
Callable Unit
Complexity
Concurrency
Critical Section
Eager Evaluation
Executor
Function Objects
Lambda Functions
Lazy evaluation
Lock-free
Lost Wakeup
Math Laws
Memory Location
Memory Model
Modification Order
Monad
Non-blocking
Parallelism
Predicate
Pattern
RAII
Release Sequence
Sequential Consistency
Sequence Point
Spurious Wakeup
Thread
Total order
TriviallyCopyable
volatile
wait-free
19
Index
Index

Invaluable Value

Patterns added an invaluable value to software development in general. Of course, this also holds true for concurrency in particular. The added value boils down to three points. A well-defined terminology, improved documentation, and learning from the best.

The well-defined terminology means that software developers can now use common and unambiguous vocabulary. Misunderstandings or verbose explanations are mainly stories of the past. If a software developer asks for an advice about how a family of similar algorithms can be implemented in such a way that they can be exchanged during runtime the answer may be as short as: use the strategy pattern. If the software developer knows the strategy pattern, he can immediately think about the consequences of using the strategy pattern; if not, he can look it up in the literature.

The documentation improves in two aspects. First, the documentation about the software system, may it be in a graphical or textual description, improves...

Previous Section
End of Section 3
Next Section