std :: map线程安全和迭代器无效

Question

I'm trying to determine if the following sample code is thread-safe:

std::map<K, V> myMap;

void foo() {
   myMap[k]; // Construct a new key-value pair with key `k`.
}

void bar() {
   auto it = myMap.find(x);
   if (it != myMap.end()) {
      std::lock_gaurd<std::mutex> lg(...);
      // do something with *it
   }
}

There are no removals taking place (atleast until the program is terminating), the only operations are adding elements in foo and iterating over them in bar . Function foo will get called from one thread and bar will get called in multiple threads, all concurrently.

Now, I understand that the STL containers are not thread-safe and I'm doing a non-const operation concurrently using myMap::operator[] . What I'm confused about is since STL find doesn't change the underlying map, and because myMap::operator[] doesn't invalidate iterators nor references, would this still be considered unsafe? I see a bit of a clash in my thinking: should I be worried because operator[] is non-const and thus I'm doing concurrent changes to the data structure, or can I consider this safe since it won't invalidate my iterator?

Answer 1

You're right to be suspicious. You can't call myMap[k] and myMap.find(x) from different threads at the same time.

With containers, you can safely do one of the following at a time:

1. Call const member functions from any number of threads concurrently, or

2. Call a non-const member function from exactly one thread.

Since operator[] is not const , you have to guard it with a mutex or otherwise ensure that you're not calling any other member functions at the same time.