有一种弱互斥锁的概念吗？

Question

让我们考虑这段代码（不一定有意义，它只是一个 MCVE）：

class Foo
{
public:
    // this function is thread safe
    void doSomething();
};

static std::mutex mutex;
static std::shared_ptr<Foo> instance;

void workerThread()
{
    while ( true )
    {
        mutex.lock();
        if ( instance )
        {
            instance->doSomething();
        }
        mutex.unlock();
        msleep( 50 );
    }
}

void messupThread()
{
    while ( true )
    {
        mutex.lock();
        instance.reset( new Foo() );
        mutex.unlock();
        msleep( 1000 );
    }
}

workerThread 对 Foo 实例执行操作。 messupThread 修改应在其上执行操作的实例。

这段代码是线程安全的。

如果你启动 10 个workerThread 就会出现问题，当一个workerThread 使用该实例时，它会锁定另外九个（而doSomething 是线程安全的，它们应该能够同时工作）。

是否有一种弱互斥/锁定机制可以使任何workerThread 阻止messupThread 更改实例但不会阻止并发workerThread 使用它。

我可以这样做，但我想知道是否有更简单的方法来使用标准对象/机制来实现它：

class Foo
{
public:
    // this function is thread safe
    void doSomething();
};

static int useRefCount = 0;
static std::mutex work_mutex; // to protect useRefCount concurrent access
static std::mutex mutex;      // to protect instance concurrent access
static std::shared_ptr<Foo> instance;

void workerThread()
{
    while ( true )
    {
        work_mutex.lock();
        if ( useRefCount == 0 )
            mutex.lock(); // first one to start working, prevent messupThread() to change instance
        // else, another workerThread already locked the mutex
        useRefCount++;   
        work_mutex.unlock();           

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

        work_mutex.lock();
        useRefCount--;
        if ( useRefCount == 0 )
            mutex.unlock(); // no more workerThread working
        //else, keep mutex locked as another workerThread is still working
        work_mutex.unlock();

        msleep( 50 );
    }
}

void messupThread()
{
    while ( true )
    {
        mutex.lock();
        instance.reset( new Foo() );
        mutex.unlock();
        msleep( 1000 );
    }
}

Answer 1

如果您可以访问std::shared_mutex，它可能会很好地解决您的问题。它基本上是一个读/写锁，但有不同的命名法：共享访问与唯一访问。

让工作线程使用shared lock，让混乱线程使用unique lock。

首选共享访问还是唯一访问，depends on the implementation。因此，您可能会看到由于大量工作线程非常频繁地占用共享锁而导致混乱线程饿死。

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

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

请注意，std::shared_mutex 是 C++17 标准的一部分。

Answer 2

如果所有线程都应该共享同一个智能指针instance，那么首先使用std::shared_ptr 没有多大意义，而是使用std::unique_ptr。

我是否可以建议每个线程都有自己的自己的std::shared_ptr，从全局instance 共享指针复制而来？然后，受锁保护，从全局共享指针复制到本地共享指针，当锁解锁时，通过本地共享指针调用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);
    }
}