std::map thread-safety

by

The C++11 standard guarantees that const method access to containers is safe from different threads (ie, both use const methods).

In addition, [container.requirements.dataraces] states

implementations are required to avoid data races when the contents of
the contained object in different elements in the same sequence,
excepting vector<bool>

In other words, except for vector<bool> modifying distinct contents is not a data race.

Now, if one thread invalidates an iterator used by another thread, clearly this is a data race (and results in undefined behavior). If one thread does non-const access to a container, and another does const access, that is a data race (and undefined behavior). (Note: a number of functions are “considered const” for the purpose of multithreading, including begin, end and other functions (and methods) that are non-const simply because they return non-const iterators. [] is included in this set of pseudo-const for thread safety reasons, except for map and unordered_set etc — 23.2.2.1).

However, it appears that if you have a reference to an element within the container, and engage in operations that do not invalidate that reference in another thread, and never write to that element in another thread, you can safely read from that reference. Similarly, if other threads never even read from the element, then writing to that element shouldn’t result in undefined behavior.

For standards references, 17.6.5.9.5 seems to guarantee that functions from the standard library won’t run away and read/write elements needlessly.

So the short answer: you are safe, so long as the other thread doesn’t directly mess with that particular entry in the map.

More Related Contents:

  1. How can I use std::maps with user-defined types as key?
  2. How to retrieve all keys (or values) from a std::map and put them into a vector?
  3. In STL maps, is it better to use map::insert than []?
  4. How can I use an array as map value?
  5. Thread safety of std::map for read-only operations
  6. C++ Thread-Safe Map
  7. Find mapped value of map
  8. Why Can’t I store references in a `std::map` in C++?
  9. Example for boost shared_mutex (multiple reads/one write)?
  10. understanding of pthread_cond_wait() and pthread_cond_signal()
  11. How to implement multithread safe singleton in C++11 without using
  12. Difference between pointer and reference as thread parameter
  13. What is the default constructor for C++ pointer?
  14. C++ Loop through Map
  15. How to use SQLite in a multi-threaded application?
  16. Delayed start of a thread in C++ 11
  17. Is it smart to replace boost::thread and boost::mutex with c++11 equivalents?
  18. C++11 STL containers and thread safety
  19. Checking value exist in a std::map – C++
  20. Heap corruption under Win32; how to locate?
  21. How are user-level threads scheduled/created, and how are kernel level threads created?
  22. How to estimate the thread context switching overhead?
  23. C++ Thread Pool [closed]
  24. OpenMP: What is the benefit of nesting parallelizations?
  25. Is MAXIMUM_WAIT_OBJECTS really 64?
  26. What is difference between const and non const key?
  27. Why there are three unexpected worker threads when a Win32 console application starts up? [duplicate]
  28. is winsock2 thread safe?
  29. Is a memory barrier required to read a value that is atomically modified?
  30. C++11 Implementation of Spinlock using header “

Leave a Comment