Can I make a C++11 class/object universally thread safe?

Question

Having read Can mutex implementations be interchanged (independently of the thread implementation), it is my understanding that I can ensure that my class is thread safe for all thread implementations, by using C++ 11 mutexes.

Am I correct in my understanding? I am expecting either yes (perhaps with caveats) or no (with reasons).

• My code may need recompilation on the target platform, but no changes are needed to my source code. (@Peter)
• Alternatively stated, I ought to be able to compile for a particular platform and deliver a .so that can be safely used with any thread library?

Given the down voting, I will try to be more precise.

Is the C++11 implementation of mutexes independent of any other thread API? Do C++11 mutexes only know about each other and implement blocking independently of how the thread of execution reached that point.

Will a C++11 mutex always work with OpenMP (with recompilation) ? Can Team A deliver a thread safe API (using C++ mutexes) for use by Team B, regardless of the particular thread API used by Team B? All code can be recompiled.

I am attaching a working example.

#include <iostream>
#include <omp.h>
#include <mutex>
class A {
    unsigned n = 0;

public:

    void inc() {
        ++n;
    }

    unsigned get() {
        return n;
    }
};

class B {
    std::mutex mutex;
    unsigned n = 0;

public:

    void inc() {
        mutex.lock();
        ++n;
        mutex.unlock();

    }

    unsigned get() {
        return n;
    }
};

int main() {

    A a;
    B b;
#pragma omp parallel for
    for (int i = 0; i < 100000; i++) {
        a.inc();
        b.inc();
    }

    std::cout << a.get() << " " << b.get() << std::endl;

}

The output of my last run was:

98015 100000

Is this by luck or design?

Answer 1

you can make your class platform-independently thread-safe if you make all its members private and all access (read/write) operations on data protected by any synchronization mechanism (std::mutex, std::atomic, or other from boost/Qt/whatever), regardless of thread API in use.

Simplest way is to use a single std::recursive_mutex/std::unique_lock pair for all data access operations (getters/setters) inside class and make data members private. It is just guaranteed to work regardless of thread API, but may be not optimal performance-wise.

Most other solutions may be or be not suitable for your specific case. Sometimes synchronization primitives are not required at all.

Answer 2

You can always use mutexes to make the member functions of a class interact without data races. But that's not enough to ensure that an object can be used from multiple threads without conflicts; you need a broader design. For example, consider writing out the contents of a vector:

int size = vec.size();
for (int i = 0; i < size; ++i)
    std::cout << vec[i] << ' ';
std::cout << '\n';

With an internal mutex, the call to vec.size() and the calls to vec::operator[] do not have data races, so they are "safe" to call from multiple threads. But this code has a problem: if another thread removes an element from the vector then the vector will be smaller than it was, and this loop will run off the end.