Synchronized unordered_map in C++

I am using unordered_map from Boost. Are there any synchronized version of unordered_map? This is because I have quite a large number of unordered_map and manually synchronizing it using lo开发者_StackOverflow社区ck would be very messy.

Thanks.

It's impossible to usefully encapsulate containers offering STL-like interfaces (which unordered_map also does) with automatic locking because there are race conditions associated with retrieving iterators and positions inside the string then trying to use them in later operations. If you can find some less flexible interface that suits your needs, perhaps putting any complex operations into single locked function calls, then you can easily wrap a thread-safe class around the container to simplify your usage.

Are you sure that is what you need ?

while (!stack.empty())
{
  Element const e = stack.top();


  stack.pop();
}

In a single thread, this code looks right. If you wish to go multi-thread however, simply having a synchronized stack just doesn't cut it.

What happens if anyone else pops the last element AFTER you tested for emptiness ?

There is more than container synchronization to go multi-thread. That said, you could try TBB out.

Use Folly's AtomicHashmap.

From Folly's documentation on Github

folly/AtomicHashmap.h introduces a synchronized UnorderedAssociativeContainer implementation designed for extreme performance in heavily multithreaded environments (about 2-5x faster than tbb::concurrent_hash_map) and good memory usage properties. Find and iteration are wait-free, insert has key-level lock granularity, there is minimal memory overhead, and permanent 32-bit ids can be used to reference each element.

It comes with some limitations though.

Intel's Thread Building Blocks library has a class tbb::concurrent_hash_map that is an unordered map, allowing concurrent access. Internally it is implemented using a fine-grained locking scheme, but the basic outcome is that you can access it without race conditions.