类成员函数的静态互斥锁: C++ 11

Question

谈到RAII

我可以为critical section使用static mutex，如下所示：

#include <string>
#include <mutex>
#include <iostream>
#include <fstream>
#include <stdexcept>

void write_to_file (const std::string & message) {
    // mutex to protect file access
    static std::mutex mutex;

    // lock mutex before accessing file
    std::lock_guard<std::mutex> lock(mutex);

    // try to open file
    std::ofstream file("example.txt");
    if (!file.is_open())
        throw std::runtime_error("unable to open file");

    // write message to file
    file << message << std::endl;

    // file will be closed 1st when leaving scope (regardless of exception)
    // mutex will be unlocked 2nd (from lock destructor) when leaving
    // scope (regardless of exception)
}

如果对类成员函数使用相同的方法，例如：

class Test{
    public:
        void setI(int k)
        {
            static std::mutex mutex;
            std::lock_guard<std::mutex> lock(mutex);
            i=k;
        }

    private:
        int i;    
};

上述方法的优缺点是什么？

使用下面的方法是否更可取：

class Test
{
public:
    void setI(int k)
    {
        std::lock_guard<std::mutex> lock(mutex);
        i = k;
    }

private:
    int i;
    std::mutex mutex;
};

哪种方法能更好地保证线程的安全性？

Answer 1

reference 1

“在成员函数中声明的静态变量将在函数调用之间保留它们的值。所有实例将只有一个副本”

你的两个解决方案都是“有效的”，这真的取决于你想要完成什么……

成员函数中的静态互斥变量

这个解决方案为类的所有实例提供了一个互斥锁。它在提供线程安全方面是有效的，但如果您有许多跨不同线程的对象，则可能不是最佳的性能。互斥锁也被限制为只有一个函数，所以这通常会使实现变得不切实际。因此，静态私有变量通常更好。

类中的私有互斥变量

在这个解决方案中，您的类的每个实例都有一个互斥锁。为您的类提供线程安全将是有效的，以便多个线程可以访问它。这通常是更好的解决方案，因为它允许不同的线程同时访问不同的对象。但是，这不足以保护对类的静态成员的访问。

大多数情况下，您希望在类中有一个私有的非静态互斥锁。

Answer 2

静态互斥内部函数似乎只有在你试图仅(且仅当)访问该函数中的某些资源时才有用。

如果你明天需要向Test类(如int getI() const;)添加一些read函数，那么你应该重构setI函数和Test类。如果要将互斥锁用作类成员，则只需使用与setI中类似的互斥锁来编写getI代码

Answer 3

我想静态互斥是很好的。因为有一种资源你需要保护。与其让类的多个实例分别拥有每个互斥锁，不如让所有互斥锁都有一个互斥锁，因为只有一个资源。

我自己只是把它想象成一种资源，就像房子一样。我们将有一个储物柜锁在右边。如果我哪里错了，请纠正我:)