Is std::vector or boost::vector thread safe?

by

The C++ standard makes certain threading guarantees for all the classes in the standard C++ library. These guarantees may not be what you’d expect them to be but for all standard C++ library classes certain thread safety guarantees are made. Make sure you read the guarantees made, though, as the threading guarantees of standard C++ containers don’t usually align with what you would want them to be. For some classes different, usually stronger, guarantees are made and the answer below specifically applies to the containers. The containers essentially have the following thread-safety guarantees:

  1. there can be multiple concurrent readers of the same container
  2. if there is one writer, there shall be no more writers and no readers

These are typically not what people would want as thread-safety guarantees but are very reasonable given the interface of the standard containers: they are intended to be used efficiently in the absence of multiple accessing threads. Adding any sort of locking for their methods would interfere with this. Beyond this, the interface of the containers isn’t really useful for any form of internal locking: generally multiple methods are used and the accesses depend on the outcome of previous accesses. For example, after having checked that a container isn’t empty() an element might be accessed. However, with internal locking there is no guarantee that the object is still in the container when it is actually accessed.

To meet the requirements which give the above guarantees you will probably have to use some form of external locking for concurrently accessed containers. I don’t know about the boost containers but if they have an interface similar to that of the standard containers I would suspect that they have exactly the same guarantees.

The guarantees and requirements are given in 17.6.4.10 [res.on.objects] paragraph 1:

The behavior of a program is undefined if calls to standard library functions from different threads may introduce a data race. The conditions under which this may occur are specified in 17.6.5.9. [ Note: Modifying an object of a standard library type that is shared between threads risks undefined behavior unless objects of that type are explicitly specified as being sharable without data races or the user supplies a locking mechanism. —endnote]

… and 17.6.5.9 [res.on.data.races]. This section essentially details the more informal description in the not.

More Related Contents:

  1. What’s the difference between “STL” and “C++ Standard Library”?
  2. How do I sort a std::vector by the values of a different std::vector?
  3. What is the performance overhead of std::function?
  4. Sorting zipped (locked) containers in C++ using boost or the STL
  5. How do I combine hash values in C++0x?
  6. Search a vector of objects by object attribute
  7. How to filter items from a std::map? [duplicate]
  8. Is the C++ std::set thread-safe?
  9. unordered_map thread safety
  10. Can std::begin work with array parameters and if so, how?
  11. STL vector and thread-safety
  12. Thread safety of std::map for read-only operations
  13. How can I use Standard Library (STL) classes in my dll interface or ABI?
  14. Does boost have a datatype for set operations that is simpler than the STL?
  15. How do I erase elements from STL containers?
  16. Is boost shared_ptr thread safe?
  17. std::mutex performance compared to win32 CRITICAL_SECTION
  18. Comparing 3 modern c++ ways to convert integral values to strings
  19. Is stl vector concurrent read thread-safe?
  20. Syntax for using std::greater when calling std::sort in C++
  21. what does `using std::swap` inside the body of a class method implementation mean?
  22. What’s the time complexity of iterating through a std::set/std::map?
  23. Conversion from boost::shared_ptr to std::shared_ptr?
  24. What can and can’t I specialize in the std namespace?
  25. How to get a random element from a C++ container?
  26. Reorder vector using a vector of indices [duplicate]
  27. Doing a static_assert that a template type is another template
  28. std::bind overload resolution
  29. How do I build boost with new Visual Studio 2013 preview?
  30. Using shared_ptr in dll-interfaces

Leave a Comment