C++ Concurrency in Action

Transcription

1 C++ Concurrency in Action Practical Multithreading ANTHONY WILLIAMS 11 MANNING Shelter Island

2 contents preface xv acknowledgments xvii about this booh xix about the cover illustration xxii ~1 Hello, world ofconcurrency in C++! What is concurrency? 2 Concurrency in computer systems 2 Approaches to concurrency Why use concurrency? 6 Using concurrency for separation of concerns 6 Using concurrency for performance to use concurrency 8 7* When not 1.3 Concurrency and multithreading in C++ 9 History of multithreading in C++ 10* Concurrency support in the new standard 10 Efficiency in the C++ Thread Library 11 * Platform-specific facilities Getting started 13 Hello, Concurrent World Summary 14 ix

3 Managing threads Basic thread management 16 Launching a thread 16* Waiting for a thread to complete 18 Waiting in exceptional circumstances 19 * Running threads in the background Passing arguments to a thread function Transferring ownership of a thread Choosing the number of threads at runtime Identifying threads Summary 32 Sharing data between threads Problems with sharing data between threads Protecting Race conditions 35* Avoiding problematic race conditions 36 shared data with mutexes 37 Using mutexes in C++ 38* Structuring code for protecting shared data 39* race Spotting conditions inherent in interfaces 40 * Deadlock: the problem and a solution 47 Further guidelines for avoiding deadlock 49 * Flexible locking with stdr.uniquejlock 54 * Transferring mutex ownership between scopes 55 * Locking at an appropriate granularity Alternative facilities for protecting shared data 59 Protecting shared data during initialization 59 * Protecting rarely updated data structures 63 * Recursive locking Summary 65 Synchronizing concurrent operations Waiting for an event or other condition 68 a Waitingfor condition with condition variables 69 Building a thread-safe queue with condition variables Waiting for one-off events with futures 76 Returning valuesfrom background tasks 77 * Associating a task with a future * 79 Making (std::)promises 81 * Saving an exception for the future 83* Waitingfrom multiple threads Waiting with a time limit 87 Clocks 87 * Durations 88 * Time points 89 Functions that accept timeouts 91

4 4.4 Using synchronization of operations to simplify code 93 Functional programming with futures 93 Synchronizing operations with message passing Summary 102 The C++ memory model and operations on atomic types Memory model basics 104 Objects and memory locations 104 Objects, memory locations, and concurrency 105 m Modification orders Atomic operations and types in C The standard atomic types 107 Operations on std::atomic_flag 110* on Operations std::atomic<bool> 112 Operations on std::atomic<t*>: pointer arithmetic 114 Operations on standard atomic integral types 116 The sldr.atomico primary class template 116 * Free functions for atomic operations Synchronizing operations and enforcing ordering 119 The synchronizes-with relationship 121 * The happens-before relationship 122 * Memory orderingfor atomic operations 123 * Release sequences and synchronizes-with 141 Fences 143 Ordering nonatomic operations with atomics Summary 147 Designing lock-based concurrent data structures What does it mean to design for concurrency? 149 Guidelines for designing data structures for concurrency Lock-based concurrent data structures 151 A thread-safe stack using locks 151 A thread-safe queue using locks and condition variables 154 * A thread-safe queue using fine-grained locks and condition variables Designing more complex lock-based data structures 169 Writing a thread-safe lookup table using locks 169 Writing a thread-safe list using locks Summary 179 Designing lock-free concurrent data structures Definitions and consequences 181 Types ofnonlocking data structures 181 Lock-free data structures 182 Wait-free data structures 182 The pros and cons of lock-free data structures 183

5 7.2 Examples of lock-free data structures 184 Writing a thread-safe stack without locks 184 Stopping those pesky leaks: managing memory in lock-free data structures 188 Detecting nodes that can't be reclaimed using hazard pointers 193 Detecting nodes in use with reference counting 200 * Applying the memory model to the lock-free stack 205 Writing a thread-safe queue without locks Guidelines for writing lock-free data structures 221 Guideline: use std::memory_order_seq_cstfor prototyping 221 Guideline: use a lock-free memory reclamation scheme 221 Guideline: watch out for the ABA problem 222 Guideline: identify busy-wait bops and help 1A Summary 223 the other thread 222 Designing concurrent code Techniques for dividing work between threads 225 Dividing data between threads before processing begins 226 Dividing data recursively 227 Dividing work by task type Factors affecting the performance ofconcurrent code 233 How many processors'! 234 Data contention and cache ping-pong 235 * False sharing 237 How close is your data? 238 Oversubscription and excessive task switching Designing data structures for multithreaded performance 239 Dividing array elements for complex operations 240 Data access patterns in other data structures Additional considerations when designing for concurrency 243 Exception safety in parallel algorithms 243 Scalability and Amdahl's law 250 * Hiding latency with multiple threads 252 Improving responsiveness with concurrency Designing concurrent code in practice 255 A parallel implementation of std::for_each 255 " A parallel implementation of std::find 257 * A parallel implementation ofstd::partial_sum Summary 272

6 xiii Advanced thread management Thread pools 274 The simplest possible thread pool 274 * Waiting for tasks submitted to a thread pool 276* Tasks that wait for other tasks 280 * Avoiding contention on the work queue 283 Work stealing Interrupting threads 289 Launching and interrupting another thread 289 * Detecting that a thread has been interrupted 291 * Interrupting a condition variable wait 291 * Interrupting a wait on std::condition_variable_any 294 Interrupting other blocking calls 296 * Handling interruptions 297 Interrupting background tasks on application exit Summary 299 Testing and debugging multithreaded applications Types of concurrency-related bugs 301 Unwanted blocking 301 * Race conditions Techniques for locating concurrency-related bugs 303 Reviewing code to locate potential bugs 303 Locating concurrency-related bugs by testing 305 Designingfor testability 307 * Multithreaded testing techniques 308 * Structuring multithreaded test code 311 Testing the performance of multithreaded code Summary 314 appendix A Brief referencefor some C++11 languagefeatures 315 appendix B Brief comparison of concurrency libraries 340 appendix C A message-passingframework and complete ATM example 342 appendix D C++ Thread Library reference 360 resources 487 index 489