CODEWITHSUNDEEP
c++multithreadingboostlockingmutex
user1002288
user1002288

Reputation: 5040

Is it possible to use mutex to lock only one element of a data structure ?

Is it possible to use mutex to lock only one element of a data structure ? e.g. 

boost::mutex m_mutex;
map<string, int> myMap;
// initialize myMap so that it has 10 elements

// then in thread 1
{
boost::unique_lock<boost::mutex> lock(m_mutex);
myMap[1] = 5 ; // write map[1]
}
// in thread 2
{ 
    boost::unique_lock<boost::mutex> lock(m_mutex);
    myMap[2] = 4 ; // write map[1]
}

My question: When thread 1 is writing map[1], thread 2 can writing map[2] at the same time ? The thread lock the whole map data structure or only an element, e.g. map[1] or map[2].

thanks

Upvotes: 2

Views: 2165

Answers (4)

rakesh
rakesh

Reputation: 2051

Mutex is all about discipline. One thread can call write and other thread can call write1. C++ runtime will assume it is intentional. But most of the cases it is not the programmer intended. Summary is as long as all threads/methods follow the discipline (understand the the critical section and respect it) there will be consistency.

int i=0;

Write()
{
    //Lock 
    i++;
    //Unlock
}

Write1()
{
    i++;
}

Upvotes: 0

Michael
Michael

Reputation: 146

Mutexes lock executable regions not objects. I always think about locking any code regions that read/modify thread objects. If an object is locked within a region but that object is accessible within another un-synchronized code region, you are not safe (ofcourse). In your case, I'd lock access to the entire object as insertions and reading from containers can easily experience context switching and thus increase the likelihood of data corruption.

Upvotes: 0

Alessandro Pezzato
Alessandro Pezzato

Reputation: 8802

You need a different mutex for every element of the map. You can do this with a map of mutex or adding a mutex to the mapped type (in your case it is int, so you can't do it without creating a new class like SharedInt)

Upvotes: 3

Kerrek SB
Kerrek SB

Reputation: 477060

If you can guarantee that nobody is modifying the container itself (via insert and erase etc.), then as long as each thread accesses a different element of the container, you should be fine.

If you need per-element locking, you could modify the element type to something that offers synchronized access. (Worst case a pair of a mutex and the original value.)

Upvotes: 4

Related Questions