c++ - 将 shared_lock 升级为独特的锁使用、时序和设计

Question

我正在更新以前使用自己的读写锁机制的代码(此代码是在 C++11 之前编写的，并且 std::shared_mutex 尚不存在)
使用标准版的 C++。

有 ReadLock 和 WriteLock 两个类，可以通过调用方法将 ReadLock 升级为 WriteLock。 WriteLock 也可以随时获得，无需从 shared_lock 升级。
阅读 shared_lock 的 C++ std 版本，我认为它很简单。

ReadLock 将被 shared_lock 替换
WriteLock 将替换为 unique_lock 并且可以随时调用 lock() 来触发以获取 Writelock
升级到 Writelock 只需两步
解锁 shared_lock 和锁定 unique_lock

我现在的问题是，当我阅读讨论时，可能会出现特定问题，并且像这样的线程引起了关注(来自 Howard Hinnant 的线程)
Can a shared lock on a std::shared_timed_mutex be upgraded to an exclusive lock?

所以我考虑使用 boost 版本，因为它支持 upgrade_lock 和 boost::upgrade_to_unique_lock，但我对如何处理它的设计感到困惑。

WriteLock 类可以同时表示 unique_lock 和/或 upgrade_lock 和 upgrade_to_unique_lock 对象，因为正如我上面提到的，WriteLock 也可以在没有 shared_lock 的情况下实现。

另外，如果我使用 boost 中的 upgrade_lock，我对如何显式触发 lock() 和 unlock() 机制感到困惑；
boost::upgrade_lock 有一个构造函数，它接受 defer_lock 作为参数，并具有我可以随时使用的 lock() 和 unlock() 方法，但是如果我们使用 boost::upgrade_to_unique_lock() 将其升级为唯一锁，我看不到相同的功能，创建 upgrade_to_unique_lock() 的对象会自动转换并锁定它。

这是我想要达到的伪代码
方法一基本操作

    void foo()
    {
        ReadLock readLock = someWrapper->AcquireReader();    // return a shared lock
        ...
        WriteLock writeLock = readLock->UpgradeToWriter();   // returns a unique lock
        writeLock->Lock();
        // do something here
    }   // writelock are unlock since constructor is called

方法 2 直接写锁

    void foo()
    {
        WriteLock writeLock = someWrapper->GetWriter();   // acquire lock straight
        writeLock->Lock();
        // do something here
    }   // writelock are unlock since constructor is called
}

所以我的问题是

我担心如果我使用 std C++ 有效，我需要使用 boost 还是 C++ std::shared_mutex 就足够了？
在上面的示例中，UpgradeToWriter() 和 GetWriter() 都将返回一个带有 unique_lock 的对象，但 Upgrade 只会先解锁 shared_lock。

如果我使用 boost 版本，我应该如何处理设计，因为 upgrade_to_unique_lock 是与 unique_lock 不同的类型？
我在想 WriteLock 类都包含 unique_lock、upgrade_lock 和 boost:upgrade_to_unique_lock 的定义，并且无论是升级还是简单的获取都会被锁定，这让我想到我的最后一个也是最后一个问题

如何为 boost:upgrade_to_unique_lock 显式或延迟/触发锁定？因为它没有 defer_lock 参数，也没有 lock() 和 unlock() 方法，只有构造函数来做他的事情？

从使用 boost::upgrade_to_unique_lock 的 boost 示例来看，所有示例都类似于下面的代码，创建一个对象会自动触发转换和锁定。

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); // <-- want this to be performed or triggered explicitly, how?
  // now we have exclusive access
}

先谢谢了，我知道这里有 C++ 专家可以帮助兄弟

Answer 1

这是你缺少的:

两个线程各有一个可升级的读锁。

两个线程都尝试将它们的读锁升级为写锁。

在所有其他读锁被释放之前，两个线程都不能向前推进。

两个线程都持有一个读锁。

这是一个僵局。所以你有两个选择:

确保这种情况永远不会发生:一次只有一个线程可以持有一个可升级的读锁。

打破死锁:当您尝试升级读锁时，结果可能是操作失败并要求线程在尝试获取写锁之前释放读锁。