【问题标题】:Is there a facility in boost to allow for write-biased locking?boost 中是否有允许写入偏向锁定的功能?
【发布时间】:2012-10-10 00:04:55
【问题描述】:

如果我有以下代码:

#include <boost/date_time.hpp>
#include <boost/thread.hpp>

boost::shared_mutex g_sharedMutex;

void reader()
{
    boost::shared_lock<boost::shared_mutex> lock(g_sharedMutex);
    boost::this_thread::sleep(boost::posix_time::seconds(10));
}

void makeReaders()
{
    while (1)
    {
        boost::thread ar(reader);
        boost::this_thread::sleep(boost::posix_time::seconds(3));
    }
}

boost::thread mr(makeReaders);
boost::this_thread::sleep(boost::posix_time::seconds(5));
boost::unique_lock<boost::shared_mutex> lock(g_sharedMutex);

...

永远不会获得唯一锁,因为总会有读者。我想要一个 unique_lock ,当它开始等待时,它可以防止任何新的读锁获得对互斥锁的访问权(根据我的 wiki 搜索,称为偏写锁或写优先锁)。有没有一种简单的方法可以通过 boost 做到这一点?还是我需要自己写?

【问题讨论】:

  • 你确认写锁永远不会被获取吗?如果是这样,如何以及在什么操作系统上?我正在查看 pthread 实现,它应该优先考虑写锁。我不完全确定 win32 实现在做什么。
  • 我实际上并没有验证这种情况 - 我确实验证了在请求写锁之后获得了新的读锁,这似乎是死锁的秘诀。我正在寻找一种保证,假设所有读锁最终都会被释放,写锁将很快获得,并且不会因为新的读锁而延迟。

标签: c++ multithreading boost


【解决方案1】:

请注意,我不会对 win32 的实现发表评论,因为它涉及更多,而且我没有时间详细介绍它。话虽如此,它的接口与 pthread 实现相同,这意味着以下答案应该同样有效。

boost::shared_mutex v1.51.0 的 pthread 实现的相关部分:

void lock_shared()
{
    boost::this_thread::disable_interruption do_not_disturb;
    boost::mutex::scoped_lock lk(state_change);

    while(state.exclusive || state.exclusive_waiting_blocked)
    {
        shared_cond.wait(lk);
    }
    ++state.shared_count;
}

void lock()
{
    boost::this_thread::disable_interruption do_not_disturb;
    boost::mutex::scoped_lock lk(state_change);

    while(state.shared_count || state.exclusive)
    {
        state.exclusive_waiting_blocked=true;
        exclusive_cond.wait(lk);
    }
    state.exclusive=true;
}

while 循环条件是与您最相关的部分。对于 lock_shared 函数(读锁),请注意只要有线程试图获取(state.exclusive_waiting_blocked)或已经拥有(state.exclusive)锁,while 循环将不会终止。这实质上意味着写锁优先于读锁。

对于锁函数(写锁),只要至少有一个线程当前拥有读锁(state.shared_count)或另一个线程拥有写锁(state.exclusive),while 循环就不会终止。这基本上为您提供了通常的互斥保证。

至于死锁,只要保证写锁一旦被获取,读锁就会一直返回。至于写锁,只要读锁和写锁总是保证一旦获得就解锁就保证返回。

如果您想知道,state_change 互斥锁用于确保没有并发调用这两个函数。我不打算介绍解锁功能,因为它们涉及更多。随意查看它们,毕竟你有源 (boost/thread/pthread/shared_mutex.hpp) :)

总而言之,这几乎是一本教科书实现,并且已经在各种场景中进行了广泛的测试(libs/thread/test/test_shared_mutex.cpp 和整个行业的大量使用)。只要您习惯性地使用它们,我就不会太担心(没有递归锁定并且总是使用 RAII 助手锁定)。如果您仍然不信任该实现,那么您可以编写一个随机测试来模拟您担心的任何测试用例,并让它在一夜之间在数百个线程上运行。这通常是梳理死锁的好方法。

现在你为什么会看到在请求写锁之后又获得了读锁?很难说没有看到您正在使用的诊断代码。可能是在您的打印语句(或您正在使用的任何内容)完成之后以及在写入线程中获取 state_change 锁之前获取读取锁。

【讨论】:

  • 只是一个无关紧要的迂腐注释。读锁实际上并不能保证总是返回。如果有一个不间断的线程流试图获取写锁,那么读锁将永远不会返回,因为写锁总是优先于读锁。如果您遇到这个问题,那么通用的 shared_lock 实现可能不会解决它。哦,你还有更大的问题要担心:)
  • 所以你是说 unique_lock 是像上面的lock() 方法那样写偏向?使用输出更新代码 - 我很确定我在适用的 shared_lock 之前到达了 unique_lock。同样在您上面的示例中,它对第一个写入者有写入偏向,但看起来第二个写入者会为 state_change 锁竞争读取线程,并且在这种情况下可能会击败写入者。
  • 好吧,我理智地检查了一下我的测试......在我在主线程中的实际测试中,我创建了一个执行wait(2); shared_lock(gLock);的读取线程,而主线程在创建此线程后立即进入unique_lock .我以为主线程会在这 2 秒内执行,但我显然错了!实际上,我自己编写的锁与您上面的非常相似,这足以让我说服我的团队采用 boost...
  • @Rollie 你说得对,第二个写锁最多只能与一个读锁竞争。这可以通过将exclusive_waiting_blocked bool 替换为像shared_count 这样的写等待计数器来轻松调整。
猜你喜欢
  • 2022-10-25
  • 1970-01-01
  • 1970-01-01
  • 2012-03-31
  • 1970-01-01
  • 1970-01-01
  • 2017-05-16
  • 1970-01-01
  • 1970-01-01
相关资源
最近更新 更多