How do I avoid rehashing overhead with std::map in multithreaded code?

When working with std::map in multithreaded C++ applications, it's crucial to avoid the overhead of rehashing. One effective strategy is to minimize the number of writes to the map and utilize locks judiciously to synchronize access. Below is a simple example demonstrating how to manage access to a shared std::map using a mutex to prevent concurrent modifications while allowing multiple threads to read from it safely.


#include <iostream>
#include <map>
#include <mutex>
#include <thread>

std::map<int, std::string> sharedMap;
std::mutex mapMutex;

void safeInsert(int key, const std::string& value) {
    std::lock_guard<std::mutex> lock(mapMutex);
    sharedMap[key] = value; // safely insert into the map
}

std::string safeAccess(int key) {
    std::lock_guard<std::mutex> lock(mapMutex);
    return sharedMap[key]; // safely access the map
}

int main() {
    std::thread t1(safeInsert, 1, "Hello");
    std::thread t2(safeInsert, 2, "World");
    t1.join();
    t2.join();

    std::cout << safeAccess(1) << " " << safeAccess(2) << std::endl;

    return 0;
}

C++ std::map multithreading rehashing mutex synchronization

How do I avoid rehashing overhead with std::map in multithreaded code?

Popular Topics

Recent Languages

How do I avoid rehashing overhead with std::map in multithreaded code?

Related Questions

Popular Topics

Recent Languages