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.

Free Chapter

Reader Testimonials

Reader Testimonials

Introduction

How you should read the book?

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

The Future: C++23

Patterns and Best Practices

Memory Model

Basics of the Memory Model

The Class Template std::atomic_ref (C++20)

The Synchronisation and Ordering Constraints

Multithreading

Thread-Local Data

Condition Variables

Parallel Algorithms of the Standard Template Library

Parallel Algorithms of the Standard Template Library

Execution Policies

The New Algorithms

The Near Future: C++20

The Near Future: C++20

A Cooperatively Interruptible Joining Thread

Atomic Smart Pointers

Latches and Barriers

Case Studies

Calculating the Sum of a Vector

Thread-Safe Initialisation of a Singleton

Ongoing Optimisation with CppMem

The Future: C++23

The Future: C++23

Extended Futures

Transactional Memory

Data-Parallel Vector Library

Patterns and Best Practices

Patterns and Best Practices

Invaluable Value

Pattern versus Best Practices

Synchronisation Patterns

Synchronisation Patterns

Dealing with Sharing

Dealing with Mutation

Concurrent Architecture

Concurrent Architecture

Half-Sync/Half-Async

Best Practices

Lock-Based Data Structures

Lock-Based Data Structures

General Considerations

Concurrent Stack

Concurrent Queue

Challenges

Blocking Issues

Breaking of Program Invariants

Lifetime Issues of Variables

Race Conditions

The Time Library

The Time Library

The Interplay of Time Point, Time Duration, and Clock

CppMem - An Overview

CppMem - An Overview

The simplified Overview

Glossary

Critical Section

Eager Evaluation

Function Objects

Lambda Functions

Lazy evaluation

Memory Location

Modification Order

Release Sequence

Sequential Consistency

Spurious Wakeup

TriviallyCopyable

Index

Customer Reviews

5 star

0

4 star

0

3 star

0

2 star

0

1 star

0

Deadlocks

A deadlock is a state in which at least one thread is blocked forever because it waits for the release of a resource, it does never get.

There are two main reasons for deadlocks:

A mutex has not been unlocked.
You lock your mutexes in a different order.

For overcoming the second issue, techniques such as lock hierachies are used in classical C++.

For the details about deadlocks and how to overcome them with modern C++, read the subsection issues of mutexes and locks.

Locking a non-recursive mutex more than once

Locking a non-recursive mutex more than once is undefined behaviour.

Locking more than once

 1 // lockTwice.cpp
 2 
 3 #include <iostream>
 4 #include <mutex>
 5 
 6 int main(){
 7 
 8    std::mutex mut;
 9 
10    std::cout << std::endl;
11    
12    std::cout << "first lock call" << std::endl;
13 
14    mut.lock();
15 
16    std::cout << "second lock call" << std::endl;
17 
18...