例如Boost Shared_mutex(多次读取/一次写入)？

Question

例如Boost Shared_mutex(多次读取/一次写入)？我有一个多线程应用程序，必须经常读取一些数据，偶尔也会更新这些数据。现在，互斥锁保持了对该数据的安全访问，但是代价很高，因为我希望多个线程能够同时读取，并且只在需要更新时将它们锁定(更新线程可以等待其他线程完成)。我想这就是boost::shared_mutex应该这样做，但我不清楚如何使用它，而且还没有找到一个明确的例子。有人可以用一个简单的例子来开始吗？

Answer 1

看起来你会做这样的事：

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}

Answer 2

1800条信息或多或少是正确的，但有几个问题我想纠正。

boost::shared_mutex _access;void reader(){
  boost::shared_lock< boost::shared_mutex > lock(_access);
  // do work here, without anyone having exclusive access}void conditional_writer(){
  boost::upgrade_lock< boost::shared_mutex > lock(_access);
  // do work here, without anyone having exclusive access

  if (something) {
    boost::upgrade_to_unique_lock< boost::shared_mutex > 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< boost::shared_mutex > lock(_access);
  // do work here, with exclusive access}

另外，与Shared_lock不同，只有单个线程可以一次获得升级锁，即使它没有升级(当我遇到它时，我觉得很尴尬)。因此，如果您的所有读者都是条件作者，则需要找到另一种解决方案。

Answer 3

您可以使用Boost创建读写锁：

#include <boost/thread/locks.hpp>#include <boost/thread/shared_mutex.hpp>typedef boost::shared_mutex Lock;typedef boost:
:unique_lock< Lock > WriteLock;typedef boost::shared_lock< Lock > ReadLock;Lock myLock;void ReadFunction(){
    ReadLock r_lock(myLock);
    //Do reader stuff}void WriteFunction(){
     WriteLock w_lock(myLock);
     //Do writer stuff}