Static Mutex for Class member Function : C++ 11

Question

Referring to RAII

I can use static mutex for a critical section as:

#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)
}

If use the same approach for a class member function such as:

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

    private:
        int i;    
};

What are the cons and pros of above approach?

Is it more advisable to use the approach as below:

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

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

which method to ensure thread safety is better?

What is the problem you are trying to solve with these solutions? — Maxim Egorushkin, Mar 03 '15 at 09:12

score 7 · Answer 1 · edited May 23 '17 at 12:16

reference 1

"Static variables declared in member functions will keep their value between function calls. There will be only one copy over all instances"

Both of your solutions is "valid", it really depends on what you want to accomplish...

static mutex variable inside member function

This solution gives you one mutex for all instances of the class. It will be effective in providing thread-safety but might not be optimal for performance if you have many objects you spread across different threads. The mutex is also limited to only that single function so usually this makes the implementation impractical. A static private variable is usually better therefore.

private mutex variable inside class

With this solution you get one mutex per instance of your class. It will be effective to provide thread safety for your class so that multiple threads can access it. This is usually the more preferred solution as it allows different threads to access different objects at the same time. However this will not be sufficient to protect access to static members of your class.

Most of the time you want to have a private non-static mutex inside your class.

score 0 · Answer 2 · edited Dec 11 '15 at 00:39

The static mutex inside function is seems to be useful only (and only) if you're trying to access some resource only (and only) in this function.

If you'll need to add some read function to class Test (like int getI() const;) tomorrow, then you should to refactor and setI function and class Test. If you'll use mutex as a class member, then you need just to write getI's code, using mutex similar as in setI

score -1 · Answer 3 · answered May 15 '21 at 05:29

I guess static mutex is good. because there is one resource you want to protect. Rather than multiple instances of class having each mutex individually, it's better to have one mutex for all since there is only one resource.

I myself just imagining as a resource like a house. we will have one locker to lock right. Please correct me if I am wrong anywhere :)

Static Mutex for Class member Function : C++ 11

3 Answers3