Example for boost shared mutex multiple reads one write

Question

I have a multithreaded app that has to read some data often  and occasionally that data is updated  Right now a mutex keeps access to that data safe  but it s expensive because I would like multiple threads to be able to read simultaneously  and only lock them out when an update is needed  the updating thread could wait for the other threads to finish    I think this is what boost  shared mutex is supposed to do  but I m not clear on how to use it  and haven t found a clear example   Does anyone have a simple example I could use to get started

User · Answer

Use a semaphore with a count that is equal to the number of readers  Let each reader take one count of the semaphore in order to read  that way they can all read at the same time  Then let the writer take ALL the semaphore counts prior to writing  This causes the writer to wait for all reads to finish and then block out reads while writing

User · Answer

It looks like you would do something like this   boost  shared mutex  access  void reader          get shared access   boost  shared lock lt boost  shared mutex gt  lock  access         now we have shared access    void writer          get upgradable access   boost  upgrade lock lt boost  shared mutex gt  lock  access         get exclusive access   boost  upgrade to unique lock lt boost  shared mutex gt  uniqueLock lock        now we have exclusive access

User · Answer

Great response by Jim Morris  I stumbled upon this and it took me a while to figure  Here is some simple code that shows that after submitting a  request  for a unique lock boost  version 1 54  blocks all shared lock requests  This is very interesting as it seems to me that choosing between unique lock and upgradeable lock allows if we want write priority or no priority    Also  1  in Jim Morris s post seems to contradict this  Boost shared lock  Read preferred    include  lt iostream gt   include  lt boost thread hpp gt   using namespace std   typedef boost  shared mutex Lock  typedef boost  unique lock lt  Lock  gt  UniqueLock  typedef boost  shared lock lt  Lock  gt  SharedLock   Lock tempLock   void main2         cout  lt  lt   10   lt  lt  endl      UniqueLock lock2 tempLock       2  queue for a unique lock     cout  lt  lt   11   lt  lt  endl      boost  this thread  sleep boost  posix time  seconds 1        lock2 unlock       void main         cout  lt  lt   1   lt  lt  endl      SharedLock lock1 tempLock       1  aquire a shared lock     cout  lt  lt   2   lt  lt  endl      boost  thread tempThread main2       cout  lt  lt   3   lt  lt  endl      boost  this thread  sleep boost  posix time  seconds 3        cout  lt  lt   4   lt  lt  endl      SharedLock lock3 tempLock       3  try getting antoher shared lock  deadlock here     cout  lt  lt   5   lt  lt  endl      lock1 unlock        lock3 unlock

User · Answer

Just to add some more empirical info  I have been investigating the whole issue of upgradable locks  and Example for boost shared mutex  multiple reads one write   is a good answer adding the important info that only one thread can have an upgrade lock even if it is not upgraded  that is important as it means you cannot upgrade from a shared lock to a unique lock without releasing the shared lock first   This has been discussed elsewhere but the most interesting thread is here http   thread gmane org gmane comp lib boost devel 214394   However I did find an important  undocumented  difference between a thread waiting for an upgrade to a lock  ie needs to wait for all readers to release the shared lock  and a writer lock waiting for the same thing  ie a unique lock     The thread that is waiting for a unique lock on the shared mutex blocks any new readers coming in  they have to wait for the writers request  This ensures readers do not starve writers  however I believe writers could starve readers   The thread that is waiting for an upgradeable lock to upgrade allows other threads to get a shared lock  so this thread could be starved if readers are very frequent    This is an important issue to consider  and probably should be documented

User · Answer

1800 INFORMATION is more or less correct  but there are a few issues I wanted to correct   boost  shared mutex  access  void reader       boost  shared lock lt  boost  shared mutex  gt  lock  access        do work here  without anyone having exclusive access    void conditional writer       boost  upgrade lock lt  boost  shared mutex  gt  lock  access        do work here  without anyone having exclusive access    if  something        boost  upgrade to unique lock lt  boost  shared mutex  gt  uniqueLock lock          do work here  but now you have exclusive access           do more work here  without anyone having exclusive access    void unconditional writer       boost  unique lock lt  boost  shared mutex  gt  lock  access        do work here  with exclusive access     Also Note  unlike a shared lock  only a single thread can acquire an upgrade lock at one time  even when it isn t upgraded  which I thought was awkward when I ran into it    So  if all your readers are conditional writers  you need to find another solution

User · Answer

Since C   17  VS2015  you can use the standard for read-write locks    include  lt shared mutex gt   typedef std  shared mutex Lock  typedef std  unique lock lt  Lock  gt  WriteLock  typedef std  shared lock lt  Lock  gt  ReadLock   Lock myLock    void ReadFunction         ReadLock r lock myLock         Do reader stuff    void WriteFunction          WriteLock w lock myLock          Do writer stuff     For older version  you can use boost with the same syntax    include  lt boost thread locks hpp gt   include  lt boost thread shared mutex hpp gt   typedef boost  shared mutex Lock  typedef boost  unique lock lt  Lock  gt   WriteLock  typedef boost  shared lock lt  Lock  gt   ReadLock

[c++] Example for boost shared_mutex (multiple reads/one write)?

Examples related to c++

Examples related to multithreading

Examples related to boost

Examples related to mutex

Examples related to boost-thread