在使用boost共享互斥体时，在什么情况下应该使用owns_lock（）函数 我正在使用一个C++多线程程序，它必须使用BooStyDyMutX读取和写入类内的一些属性。程序在执行时创建类a的多个对象实例。此类A有一个由所有A类对象共享的静态共享\u互斥体。如果该类的某个属性需要写入其中一个对象实例中，则特定对象实例需要通过将共享互斥锁升级为唯一锁来获得对共享互斥锁的独占访问。但是，在此之前，set方法检查类实例是否拥有锁，这在我看来有点奇怪

这或多或少是A类hpp文件的外观：

#include <boost/thread.hpp>

class A{
    private:
        //Private methods
        void setAttribute(boost::upgrade_lock<boost::shared_mutex>& lock, const bool value);
        //Private variables
        static boost::shared_mutex mainMutex;
        mutable bool attribute;
    public:
        //... Some public methods using setAttribute
}

void A::setAttribute(boost::upgrade_lock<boost::shared_mutex>& lock, const bool value)
{
    (void)lock;
    assert(lock.owns_lock());

    //get exclusive access to the lock
    const boost::upgrade_to_unique_lock<boost::shared_mutex> ulock(lock);
    attribute = value;
}

#包括
甲级{
私人：
//私有方法
void setAttribute（boost：：升级锁定和锁定，const bool值）；
//私有变量
静态boost：：共享_互斥体main互斥体；
可变布尔属性；
公众：
//…一些使用setAttribute的公共方法
}

这就是A类cpp文件的外观：

#include <boost/thread.hpp>

class A{
    private:
        //Private methods
        void setAttribute(boost::upgrade_lock<boost::shared_mutex>& lock, const bool value);
        //Private variables
        static boost::shared_mutex mainMutex;
        mutable bool attribute;
    public:
        //... Some public methods using setAttribute
}

void A::setAttribute(boost::upgrade_lock<boost::shared_mutex>& lock, const bool value)
{
    (void)lock;
    assert(lock.owns_lock());

    //get exclusive access to the lock
    const boost::upgrade_to_unique_lock<boost::shared_mutex> ulock(lock);
    attribute = value;
}

void A:：setAttribute（boost:：upgrade\u lock&lock，const bool值）
{
（d）锁；
断言（lock.owns_lock（））；
//以独占方式访问锁
const boost：：将_升级为_unique _lockulock（锁）；
属性=值；
}

所以，我的问题是，既然method setAttribute是私有的，并且它仅由类中的方法使用，为什么我需要检查传递的锁是否拥有该锁。有什么情况我应该考虑这样做吗？

< P> >代码>（空）锁；<存在代码>条件，以避免在编译期间使用类似于

g++-DNDEBUG-Wall-Werror-pedantic的东西时出现编译错误。这指示编译器在未使用变量的所有警告（除其他外）时停止。当程序员不知道变量是否会被使用，但又不想破坏构建时，有时会在代码中使用这种技术

owns\u lock（）
方法表示特定对象已获得锁的所有权。或者换一种说法，锁定对象。如果它是一个共享锁，那么多个对象可以“拥有”它owned与locked by this object同义。如果它是唯一的锁，那么只有一个对象可以拥有它

assert（）；即使锁不属于线程（例如，它已解锁）。如果这是真的，那么升级将无声地失败

例如，如果在禁用
assert
的情况下发生如下操作顺序，代码将自动失败：

boost::upgrade_lock<boost::shared_mutex> lock(this->mainMutex);
lock.unlock();
this->setAttribute(lock, false);

boost:：升级锁（这个->主互斥锁）；
lock.unlock（）；
此->设置属性（锁定，错误）；

upgrade\u lock
调用获取锁的升级所有权。这意味着有一个合同说这个对象可以升级锁

upgrade\u to\u unique\u lock
调用通过暂停将共享锁实际升级为唯一锁，直到任何其他共享所有者释放锁。如果调用该锁时该锁不属于该对象，则它将自动无法将该锁升级为唯一锁

TLDR；我怀疑作者的意图是将互斥代码保持为类的私有代码，但希望在
setattribute（）
（void）lock之前的某个地方意外调用unlock（）时放置一个断言这是什么？从我看到的有关如何使用共享互斥的示例中，它们总是调用lock（），然后升级到唯一锁以获得独占访问。因此，“（void）lock”似乎调用了一个重载操作符，该操作符调用升级锁的lock（）函数？然而，我不是100%肯定这一点，因为到目前为止，我还无法通过“从我看到的示例”链接所做的研究来证实这一点？这是我看到的关于如何使用共享互斥体的示例之一：。当线程尝试写入时，他们首先创建一个升级锁，将共享互斥锁作为输入，然后使用升级锁到唯一锁来获得独占访问。这里的升级锁是作为引用传递的，所以我想可能是
（void）lock
正在进行实例化，或者是一些副作用，它是获得可升级访问权限所必需的，然后发布一个指向它的链接！！！