Sign In Start Free Trial

Book Overview & Buying
Table Of Contents

Concurrency with Modern C++

By : Rainer Grimm

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

Introduction

Conventions

Source Code

How you should read the book?

Personal Notes

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

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

Multithreading

Multithreading

Threads

Shared Data

Thread-Local Data

Condition Variables

Tasks

Parallel Algorithms of the Standard Template Library

Parallel Algorithms of the Standard Template Library

Execution Policies

Algorithms

The New Algorithms

Performance

The Near Future: C++20

The Near Future: C++20

A Cooperatively Interruptible Joining Thread

Atomic Smart Pointers

Latches and Barriers

Semaphores

Coroutines

Case Studies

Case Studies

Calculating the Sum of a Vector

Thread-Safe Initialisation of a Singleton

Ongoing Optimisation with CppMem

Conclusion

The Future: C++23

The Future: C++23

Executors

Extended Futures

Transactional Memory

Task Blocks

Data-Parallel Vector Library

Patterns and Best Practices

Patterns and Best Practices

History

Invaluable Value

Pattern versus Best Practices

Anti-Pattern

Synchronisation Patterns

Synchronisation Patterns

Dealing with Sharing

Dealing with Mutation

Concurrent Architecture

Concurrent Architecture

Active Object

Monitor Object

Half-Sync/Half-Async

Best Practices

Best Practices

General

Multithreading

Memory Model

Lock-Based Data Structures

Lock-Based Data Structures

General Considerations

Concurrent Stack

Concurrent Queue

Challenges

Challenges

ABA Problem

Blocking Issues

Breaking of Program Invariants

Data Races

Deadlocks

False Sharing

Lifetime Issues of Variables

Moving Threads

Race Conditions

The Time Library

The Time Library

The Interplay of Time Point, Time Duration, and Clock

Time Point

Time Duration

Clocks

Sleep and Wait

CppMem - An Overview

CppMem - An Overview

The simplified Overview

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

Index

Index

Time Duration

Time duration std::chrono::duration is a class template that consists of the type of the tick Rep and the length of a tick Period.

The class template std::chrono::duration

template<
    class Rep,
    class Period = std::ratio<1>
> class duration;

The tick length is by default std::ratio<1>. std::ratio<1> stands for a second and can also be written as std::ratio<1, 1>. The rest is quite easy. std::ratio<60> is a minute and std::ratio<1,1000> a millisecond. When the type of Rep is a floating-point number, you can use it to hold fractions of time ticks.

C++11 predefines the most important time durations:

Important time durations

typedef duration<signed int, nano> nanoseconds;
typedef duration<signed int, micro> microseconds;
typedef duration<signed int, milli> milliseconds;
typedef duration<signed int> seconds;
typedef duration<signed int, ratio< 60>> minutes;
typedef duration<signed...

CONTINUE READING

83

Tech Concepts

36

Programming languages

73

Tech Tools

Unlimited access to the largest independent learning library in tech of over 8,000 expert-authored tech books and videos.

Innovative learning tools, including AI book assistants, code context explainers, and text-to-speech.

50+ new titles added per month and exclusive early access to books as they are being written.

Concurrency with Modern C++

Search

Your notes and bookmarks