https://cppcon.org
---

Threads vs Coroutines — Why C++ Has Two Concurrency Models - Conor Spilsbury - CppCon 2025
---

The C++11 standard introduced a powerful set of tools for concurrency such as threads, mutexes, condition variables, and futures. More recently, C++20 introduced another powerful but fundamentally different concurrency abstraction in the form of coroutines. But coroutines are not just an evolution or a replacement for threads. Instead, they each solve different problems in different ways. Choosing the right tool for the job requires understanding how each works under the hood and where they shine. This talk will help build that intuition by looking at how each interacts with the operating system and hardware which will help make better decisions when choosing which to use. 
 
We'll explore how threads and synchronization primitives work at the operating-system and hardware level, from thread creation and scheduling to where context switching and synchronization introduce performance costs. We’ll then contrast this to the coroutine model introduced in C++20 which takes a fundamentally different approach by using a cooperative model based on the suspension and resumption of work. 
 
Given this understanding, we’ll finish by applying this intuition to a set of real-world scenarios to identify whether threads or coroutines are a better fit for the problem at hand. 

---

Slides: https://github.com/CppCon/CppCon2025/blob/main/Presentations/Threads_vs_Coroutines.pdf

Work at Hudson River Trading (HRT): https://tinyurl.com/safxfctf
---

Conor Spilsbury
 
Conor Spilsbury is a Senior Software Engineer at Bloomberg, where he works on the Listed Securities’ Execution Management System (EMSX). EMSX is a high-performance, high-throughput multi-asset trading solution. Conor is also the chair of Bloomberg's C++ Guild. He holds a master’s degree in mathematics from the University of Exeter.
---

CppCon is the annual, week-long face-to-face gathering for the entire C++ community. The conference is organized by the C++ community for the community. You will enjoy inspirational talks and a friendly atmosphere designed to help attendees learn from each other, meet interesting people, and generally have a stimulating experience. Taking place this year in Aurora, Colorado, near the Denver airport, and including multiple diverse tracks, the conference will appeal to anyone from C++ novices to experts.
Annual CppCon Conference - https://www.cppcon.org
https://www.linkedin.com/company/cppcon
https://x.com/cppcon
https://www.facebook.com/CppConference
https://www.reddit.com/r/cppcon/
https://mastodon.social/@CppCon
---

Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
YouTube Channel Managed by Digital Medium Ltd: https://events.digital-medium.co.uk
---

#cpp #cplusplus #cppcon #cppprogramming #cplusplusprogramming #softwaredevelopment #softwareengineering #coding #code #computerscience #technology #technews #programming #programmer

ISO C++ is the official website for the C++ programming language standardization committee, providing information, resources, and updates on the evolution of the C++ language. With a focus on language features, library enhancements, and standardization efforts, ISO C++ keeps developers informed about the latest developments in C++ programming. Developers can learn about upcoming language features, review proposals for language changes, and contribute to the evolution of the C++ language through active participation in the standardization process.

A CppCon 2025 talk by Conor Spilsbury (Bloomberg) explaining why C++ has two concurrency models: threads and coroutines. The talk walks through the scaling limits of raw threads (context switching overhead, over-subscription), how thread pools partially address this, and why event loops and cooperative scheduling via coroutines are better suited for IO-bound workloads. Key concepts covered include parallelism vs. concurrency, preemptive vs. cooperative scheduling, stackless coroutine frames, and how C++20 coroutines allow writing non-blocking code in a linear style. The talk also touches on CPU-bound vs. IO-bound work tradeoffs, and previews C++26 std::execution for composing mixed workloads.