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

Multithreading

Threads

Threads are the basic building blocks for writing concurrent programs.

Minimise thread creation

How expensive is a thread? Quite expensive! This is the issue behind this best practice. Let me first talk about the usual size of a thread and than about the costs of its creation.

Size

A `std::thread is a thin wrapper around the native thread. This means I’m interested in the size of a Windows thread and a POSIX thread because most of the times they are internally used.

  • Windows systems: the post Thread Stack Size gave me the answer: 1 MB.
  • POSIX systems: the pthread_create man-page provides me with the answer: 2MB. This is the sizes for the i386 and x86_64 architectures. If you want to know the sizes for further architectures that support POSIX, here are they:
Stack size of an `std::thread`
Stack size of an std::thread

Creation

I didn’t find numbers how much time it takes to create a thread. To get a gut feeling, I made a simple performance test on...

Previous Section
End of Section 3
Next Section