C++ 有一种弱互斥的概念吗？ 让我们考虑一下这段代码（不一定是有意义的，只是一个MCVE）：

如果所有线程都应该共享同一个智能指针

实例

，那么首先使用

std:：shared_ptr

没有多大意义，而是使用

std:：unique_ptr

我是否可以建议每个线程都有自己的

std:：shared_ptr

，从全局

实例

共享指针复制？然后，受锁保护，从全局共享指针复制到本地共享指针，当锁解锁时，通过本地共享指针调用

doSomething

函数

也许像

void workerThread()
{
    std::shared_ptr<Foo> local_instance;

    while (true)
    {
        {
            std::scoped_lock lock(mutex);
            local_instance = instance;
        }

        if (local_instance)
        {
            local_instance->doSomething();
        }

        msleep(50);
    }
}

void workerThread（）
{
std:：共享的\u ptr本地\u实例；
while（true）
{
{
std：：作用域锁定（互斥）；
本地_实例=实例；
}
if（本地_实例）
{
本地_实例->doSomething（）；
}
msleep（50）；
}
}

如果所有线程都应该共享同一个智能指针

实例

，那么首先使用

std:：shared_ptr

没有多大意义，而是使用

std:：unique_ptr

我是否可以建议每个线程都有自己的

std:：shared_ptr

，从全局

实例

共享指针复制？然后，受锁保护，从全局共享指针复制到本地共享指针，当锁解锁时，通过本地共享指针调用

doSomething

函数

也许像

void workerThread()
{
    std::shared_ptr<Foo> local_instance;

    while (true)
    {
        {
            std::scoped_lock lock(mutex);
            local_instance = instance;
        }

        if (local_instance)
        {
            local_instance->doSomething();
        }

        msleep(50);
    }
}

void workerThread（）
{
std:：共享的\u ptr本地\u实例；
while（true）
{
{
std：：作用域锁定（互斥）；
本地_实例=实例；
}
if（本地_实例）
{
本地_实例->doSomething（）；
}
msleep（50）；
}
}

如果您有权访问，它可能会很好地解决您的问题。它基本上是一个读/写锁，但有不同的术语：共享访问和唯一访问

让工作线程取a，让messup线程取a

无论是共享访问还是唯一访问是首选。因此，您可能会看到messup线程被饿死，因为大量工作线程频繁地使用共享锁

// Worker thread:
std::shared_lock<std::shared_mutex> lock(m_mutex);

// Messup thread:
std::unique_lock<std::shared_mutex> lock(m_mutex);

//工作线程：
std：：共享_锁（m_互斥）；
//Messup线程：
std：：唯一的_锁（m_互斥）；

请注意，

std:：shared_mutex

是C++17标准的一部分。

如果您可以访问，它可能会很好地解决您的问题。它基本上是一个读/写锁，但有不同的术语：共享访问和唯一访问

让工作线程取a，让messup线程取a

无论是共享访问还是唯一访问是首选。因此，您可能会看到messup线程被饿死，因为大量工作线程频繁地使用共享锁

// Worker thread:
std::shared_lock<std::shared_mutex> lock(m_mutex);

// Messup thread:
std::unique_lock<std::shared_mutex> lock(m_mutex);

//工作线程：
std：：共享_锁（m_互斥）；
//Messup线程：
std：：唯一的_锁（m_互斥）；

---

<> >注意：代码> STD:：SydDyMutX < /C>是C++ 17标准的一部分。

实际上，我在MVCE中使用了<代码> SyddYPPT/<代码（以避免发布带有内存泄漏的代码），但是我的原始代码使用原始指针…@ JPO38，也许您应该考虑实际使用共享指针？实际上，我在MVCE中使用了<代码> SysDypTrp/代码>（以避免用内存泄漏发布代码），但是我的原始代码使用原始指针…@ JPO38也许您应该考虑实际使用共享指针？我想你想要的是-你想要正常的

messupThread

到

lock（）

/

unlock（）

和

workerThread

到

lock\u shared（）

/

unlock\u shared（）。这个答案可能有用：我想你想要的是-你想要
messupThread
正常地
lock（）
/
unlock（）
和
workerThread
锁定共享（）

/

unlock\u shared（）

。我相信你可能正在寻找

std:：shared\u mutex

。这种模式被称为“单写器/多读器。这个答案可能有用：然后您只需直接使用pthread库和其中的读写互斥体。或者您可以使用Boost，它还提供了锁定功能。@jpo38有趣的是，

std:：shared_lock

是C++14标准的一部分。因此，您可以将其与另一个

shared_mutex

实现结合使用，并在转到C++17后将其替换。@jpo38在

C++14

中，您可以使用它。@Galik:实际上，我使用的是boost，它提供了共享_mutex。只需在建议的代码中用

boost

替换

std

，然后直接使用pthread库和其中的读写互斥体即可。或者您可以使用Boost，它还提供了锁定功能。@jpo38有趣的是，

std:：shared_lock

是C++14标准的一部分。因此，您可以将其与另一个

shared_mutex

实现结合使用，并在转到C++17后将其替换。@jpo38在

C++14

中，您可以使用它。@Galik:实际上，我使用的是boost，它提供了共享_mutex。在提议的代码中，只需用

boost

替换

std

。