C++17 std::shared_mutex的替代方案boost::shared_mutex

C++17 std::shared_mutex的替代方案boost::shared_mutex

C++17 boost 

std::shared_mutex

http://en.cppreference.com/w/cpp/thread/shared_mutex

 

GCC5.1才會支持C++17 std::shared_mutex，替代方案是boost::shared_mutex。

 

boost::shared_mutex官方文檔：http://www.boost.org/doc/libs/1_60_0/doc/html/thread/synchronization.html#thread.synchronization.mutex_types.shared_mutex

 

需要的lib：

#pragma comment(lib, "libboost_chrono-vc140-mt-1_60.lib")
#pragma comment(lib, "libboost_date_time-vc140-mt-1_60.lib")
#pragma comment(lib, "libboost_system-vc140-mt-1_60.lib")
#pragma comment(lib, "libboost_system-vc140-mt-1_60.lib")
#pragma comment(lib, "libboost_thread-vc140-mt-1_60.lib")

 

 

boost::shared_mutex用法示例：

參考自：http://stackoverflow.com/questions/3896717/example-of-how-to-use-boost-upgradeable-mutexes

Cpp代碼  

#include <boost/thread/locks.hpp>    
#include <boost/thread/shared_mutex.hpp>    
  
int  
main()  
{  
    typedef boost::shared_mutex Mutex;  
    typedef boost::shared_lock<Mutex> ReadLock;  
    typedef boost::unique_lock<Mutex> WriteLock;  
    Mutex mutex;  
  
    {  
        // acquire read lock  
        ReadLock read( mutex );  
  
        // do something to read resource  
    }  
  
    {  
        // acquire write lock  
        WriteLock write( mutex, boost::adopt_lock_t() );  
  
        // do something to write resource  
    }  
}  

 

 

 參考自：http://stackoverflow.com/questions/989795/example-for-boost-shared-mutex-multiple-reads-one-write

Cpp代碼  

boost::shared_mutex _access;  
void reader()  
{  
  // get shared access  
  boost::shared_lock<boost::shared_mutex> lock(_access);  
  
  // now we have shared access  
}  
  
void writer()  
{  
  // get upgradable access  
  boost::upgrade_lock<boost::shared_mutex> lock(_access);  
  
  // get exclusive access  
  boost::upgrade_to_unique_lock<boost::shared_mutex> uniqueLock(lock);  
  // now we have exclusive access  
}  

 

其他參考：

How to make a multiple-read/single-write lock from more basic synchronization primitives?

http://stackoverflow.com/questions/27860685/how-to-make-a-multiple-read-single-write-lock-from-more-basic-synchronization-pr

 

使用boost::shared_mutex實現讀寫鎖

 

偉大的Boost庫給我們提供了 shared_mutex  類，結合 unique_lock 與 shared_lock 的使用，可以實現讀寫鎖。

 

通常讀寫鎖需要完成以下功能：

1.當 data 被線程A讀取時，其他線程仍可以進行讀取卻不能寫入

2.當 data 被線程A寫入時，其他線程既不能讀取也不能寫入

 

對應於功能1,2我們可以這樣來描述：

1.當線程A獲得共享鎖時，其他線程仍可以獲得共享鎖但不能獲得獨占鎖

2.當線程A獲得獨占鎖時，其他線程既不能獲得共享鎖也不能獲得獨占鎖

 

typedef boost::shared_lock<boost::shared_mutex> read_lock;
typedef boost::unique_lock<boost::shared_mutex> write_lock;
 
boost::shared_mutex read_write_mutex;
int32_t data = 1;
 
//線程A,讀data
{
    read_lock rlock(read_write_mutex);
    std::cout << data << std:; endl;
}
 
//線程B,讀data
{
    read_lock rlock(read_write_mutex);
    std::cout << data << std:; endl;
}
 
//線程C,寫data
{
    write_lock rlock(read_write_mutex);
    data = 2;
}

 

通過 shared_lock 為 shared_mutex 上鎖之后，線程將獲得其共享鎖，此時其他線程仍可以獲得共享鎖來讀取 data，但是此時 unique_lock 將無法為 shared_mutex 上獨占鎖，功能1實現了。通過 unique_lock 為 shared_lock 上鎖之后，線程將獲得獨占鎖，此時無法再被上鎖，功能2頁實現了。