Structured Concurrency in C++

Mateusz Pusz

⏱ 2-day-workshop
09:00-18:00, Monday, 15th - Tuesday, 16th April 2024
Today, C++ software is increasingly asynchronous and parallel, a trend that is likely only to continue going forward. While the C++ Standard Library has a rich set of concurrency primitives and lower-level building blocks, we lack a standard framework for asynchrony and parallelism that C++ programmers desperately need.

Asynchrony and parallelism appear everywhere, from processor hardware interfaces to networking, to file I/O, to GUIs, to accelerators. Every C++ domain and every platform needs to deal with asynchrony and parallelism, from scientific computing to video games to financial services, from the smallest mobile devices to your laptop to GPUs in the world's fastest supercomputer.

This training shows that concurrency is not only about the C++ Standard Library threading and synchronization low-level tools. During the workshop, you will learn how to write efficient, asynchronous, and highly concurrent code without the need for any manual synchronization between threads, leading to simpler code and faster runtimes. During the hands-on exercises, you will implement coroutine tools from scratch and create parallel processing pipelines with a new framework called Senders/Receivers proposed for standardization as a part of C++26. The Senders/Receivers framework is publicly available on GitHub so that it can be used in production immediately without the need to wait for the next C++ release.

During the workshop, we will work with the latest version of the compiler thanks to the Compiler Explorer, so no special environment preparation is needed.


  • Understanding what structured concurrency is and how it helps in writing thread-safe code without the need for additional synchronization
  • A detailed discussion of coroutine machinery and its suspend and customization points
  • Introduction of schedulers, senders, and receivers abstractions, as well as an overview of all the asynchronous algorithms provided by the Sender/Receiver framework


  • 40% lecture
  • 60% hands-on coding


A recent experience in implementing simple class templates is welcomed.


  1. Asynchronous Programming with Coroutines

  2. Coroutine keywords, restrictions, suspend points

  3. Coroutine return type
  4. std::coroutine_traits
  5. Coroutine promise interface
  6. std::coroutine_handle
  7. Awaiters and Awaitables
  8. Symmetric Control Transfer
  9. C++ exceptions support
  10. Eager and Lazy Tasks
  11. async with coroutines
  12. sync_await

  13. Structured Concurrency with Senders and Receivers

  14. Motivation

  15. The structure of an asynchronous processing pipeline
  16. Data parallelism with senders
  17. Cancellation support
  18. Transferring the work
  19. Sender factories
  20. Sender adaptors
  21. Sender consumers
  22. Implementing an asynchronous algorithm
  23. Sender/Receivers and Coroutines
🏷 design
🏷 architecture
🏷 interfaces
🏷 Modern C++
🏷 templates
🏷 couroutines
🏷 concurrency
🏷 senders/receivers

Mateusz Pusz

A software architect, principal engineer, and security champion with over 20 years of experience designing, writing, and maintaining C++ code for fun and living. A trainer with over 10 years of C++ teaching experience, consultant, conference speaker, and evangelist. His main areas of interest and expertise are Modern C++, code performance, low latency, safety, and maintainability.

Mateusz worked at Intel for 13 years, and now he is a Principal Software Engineer and the head of the C++ Competency Center at EPAM Systems. He is also a founder of Train IT, which provides dedicated C++ trainings and consulting services to corporations worldwide.

Mateusz is a contributor and an active voting member of the ISO C++ Committee (WG21), where, together with the best C++ experts in the world, he shapes the future of the C++ language.