Mutex lock on write only

Question

I have a multithreaded C++ application which holds a complex data structure in memory (cached data).

Everything is great while I just read the data. I can have as many threads as I want access the data.

However the cached structure is not static.

• If the requested data item is not available it will be read from database and is then inserted into the data tree. This is probably also not problematic and even if I use a mutex while I add the new data item to the tree that will only take few cycles (it's just adding a pointer).
• There is a Garbage Collection process that's executed every now and then. It removes all old items from the tree. To do so I need to lock the whole thing down to make sure that no other process is currently accessing any data that's going to be removed from memory. I also have to lock the tree while I read from the cache so that I don't remove items while they are processed (kind of "the same thing the other way around").

"Pseudocode":

function getItem(key)
   lockMutex()
   foundItem = walkTreeToFindItem(key)
   copyItem(foundItem, safeCopy)
   unlockMutex()
   return safeCopy
end function

function garbageCollection()
   while item = nextItemInTree
      if (tooOld) then
         lockMutex()
         deleteItem(item)
         unlockMutex()
      end if
   end while
end function

What's bothering me: That this means, that I have to lock the tree while I'm reading, which means that I can't have two reading processes at the same time anymore.

Any suggestions?

Is there some kind of "this is a readonly action that only collides with writes" Mutex?

Answer 1

Look into read-write-lock.

You didn't specify which framework can you use but both pThread and boost have implemented that pattern.

Answer 2

I suggest a reader-writer lock. The idea is you can acquire a lock for "reading" or for "writing", and the lock will allow multiple readers, but only one writer. Very handy.

Answer 3

The concept is a "shared reader, single writer" lock as others have stated. In Linux environments you should be able to use pthread_rwlock_t without any framework. I would suggest looking into boost::shared_lock as well.