我有一个多线程应用程序，它必须经常读取一些数据，并且偶尔会更新这些数据。现在，互斥锁可以安全地访问该数据，但它很昂贵，因为我希望多个线程能够同时读取，并且仅在需要更新时将它们锁定（更新线程可以等待其他线程完成） .
我认为这是boost::shared_mutex应该做的，但我不清楚如何使用它，也没有找到一个明确的例子。
有没有人有一个简单的例子可以用来入门？
【问题讨论】：
标签： c++ multithreading boost mutex boost-thread
1800 INFORMATION 或多或少是正确的，但我想更正一些问题。
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 不同，只有一个线程可以一次获取 upgrade_lock，即使它没有升级（当我遇到它时我觉得这很尴尬）。所以，如果你所有的读者都是有条件的作家，你需要找到另一个解决方案。
【讨论】：
boost::unique_lock< boost::shared_mutex > lock(lock); 的行改为boost::unique_lock< boost::shared_mutex > lock( _access ); 吗？
看起来你会做这样的事情：
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
}
【讨论】：
从 C++ 17 (VS2015) 开始，您可以使用标准的读写锁：
#include <shared_mutex>
typedef std::shared_mutex Lock;
typedef std::unique_lock< Lock > WriteLock;
typedef std::shared_lock< Lock > ReadLock;
Lock myLock;
void ReadFunction()
{
ReadLock r_lock(myLock);
//Do reader stuff
}
void WriteFunction()
{
WriteLock w_lock(myLock);
//Do writer stuff
}
对于旧版本，您可以使用相同语法的 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;
【讨论】：
typedef boost::unique_lock< Lock > WriteLock; typedef boost::shared_lock< Lock > ReadLock;。
只是为了补充一些经验信息，我一直在调查可升级锁的整个问题，Example for boost shared_mutex (multiple reads/one write)? 是一个很好的答案，添加了重要信息，即即使未升级，也只有一个线程可以拥有 upgrade_lock，即很重要，因为这意味着您不能在不先释放共享锁的情况下从共享锁升级到唯一锁。 （这已经在别处讨论过，但最有趣的线程在这里http://thread.gmane.org/gmane.comp.lib.boost.devel/214394）
但是，我确实发现了等待升级到锁的线程（即需要等待所有读取器释放共享锁）和等待相同事物的写入器锁（即 unique_lock）之间的重要（未记录）区别)。
在 shared_mutex 上等待 unique_lock 的线程会阻塞任何新的读者进入，他们必须等待作者的请求。这样可以确保读者不会饿死作者（但我相信作者可能会饿死读者）。
等待 upgradeable_lock 升级的线程允许其他线程获得共享锁，因此如果读者非常频繁，该线程可能会被饿死。
这是一个需要考虑的重要问题，可能应该记录在案。
使用计数等于阅读器数量的信号量。让每个读者对信号量进行计数以便阅读，这样他们就可以同时阅读。然后让编写者在编写之前获取所有信号量计数。这会导致写入器等待所有读取完成，然后在写入时阻止读取。
【讨论】：
吉姆·莫里斯（Jim Morris）的反应很好，我偶然发现了这一点，我花了一段时间才弄清楚。这是一些简单的代码，显示在提交 unique_lock boost（版本 1.54）的“请求”后会阻止所有 shared_lock 请求。这很有趣，因为在我看来，如果我们想要写入优先级或不优先级，则可以在 unique_lock 和 upgradeable_lock 之间进行选择。
Jim Morris 的帖子中的 (1) 似乎也与此相矛盾： Boost shared_lock. Read preferred?
#include <iostream>
#include <boost/thread.hpp>
using namespace std;
typedef boost::shared_mutex Lock;
typedef boost::unique_lock< Lock > UniqueLock;
typedef boost::shared_lock< Lock > SharedLock;
Lock tempLock;
void main2() {
cout << "10" << endl;
UniqueLock lock2(tempLock); // (2) queue for a unique lock
cout << "11" << endl;
boost::this_thread::sleep(boost::posix_time::seconds(1));
lock2.unlock();
}
void main() {
cout << "1" << endl;
SharedLock lock1(tempLock); // (1) aquire a shared lock
cout << "2" << endl;
boost::thread tempThread(main2);
cout << "3" << endl;
boost::this_thread::sleep(boost::posix_time::seconds(3));
cout << "4" << endl;
SharedLock lock3(tempLock); // (3) try getting antoher shared lock, deadlock here
cout << "5" << endl;
lock1.unlock();
lock3.unlock();
}
【讨论】：