Thread Safety Of a single variable

Question

I understand the concept of thread safety. I am looking for advice to simplify thread safety when trying to protect a single variable.

Say I have a variable:

double aPass;

and I want to protect this variable, so i create a mutex:

pthread_mutex_t aPass_lock;

Now there are two good ways i can think of doing this but they both have annoying disadvantages. The first is to make a thread safe class to hold the variable:

class aPass {
    public:
        aPass() {
            pthread_mutex_init(&aPass_lock, NULL);
            aPass_ = 0;
        }

        void get(double & setMe) {
            pthread_mutex_lock(aPass_lock);
            setMe = aPass_
            pthread_mutex_unlock(aPass_lock);
        }

        void set(const double setThis) {
            pthread_mutex_lock(aPass_lock);
            aPass_ = setThis;
            pthread_mutex_unlock(aPass_lock);
        }
    private:
        double aPass_;
        pthread_mutex_t aPass_lock;
};

Now this will keep aPass totally safe, nothing can be mistaken and ever touch it, YAY! however look at all that mess and imagine the confusion when accessing it. gross.

The other way is to have them both accessible and to make sure you lock the mutex before you use aPass.

pthread_mutex_lock(aPass_lock);
   do something with aPass
pthread_mutex_unlock(aPass_lock);

But what if someone new comes on the project, what if you forget one time to lock it. I don't like debugging thread problems they are hard.

Is there a good way to (using pthreads because i have to use QNX which has little boost support) To lock single variables without needing a big class and that is safer then just creating a mutex lock to go with it?

this variable is a global variable? i dont think u have much other choice.. unless you want to make a generic thread safe container class - this would save you some code if you have to do this to a second var. — Karthik T, Nov 09 '12 at 01:21
also, isnt it possible by ur design to duplicate the var? apass is a class so i can have as many objects as i want — Karthik T, Nov 09 '12 at 01:22
yeah, but what if i want to protect an int? 2 classes, now a char and a time_t, 4 classes ... etc — Fantastic Mr Fox, Nov 09 '12 at 01:24

score 25 · Accepted Answer · answered Nov 09 '12 at 12:42

25

std::atomic<double> aPass;

provided you have C++11.

answered Nov 09 '12 at 12:42

Pete Becker

74,985
8
76
165

6

unfortunately no, i do not have c++11 – Fantastic Mr Fox Nov 10 '12 at 01:42
51

Yay, i have it now! – Fantastic Mr Fox Apr 07 '20 at 15:11
11

You are featured on reddit ! https://www.reddit.com/r/ProgrammerHumor/comments/liybv2/he_finally_got_c11_8_years_later/ – Matthew Developer Feb 13 '21 at 18:41
6

Lol, this is amazing. Also I only got it because I moved company, pretty sure the old company is still on c++03 :p – Fantastic Mr Fox Feb 14 '21 at 23:46

score 3 · Answer 2 · edited Nov 09 '12 at 02:37

3

To elabourate on my solution, it would be something like this.

template <typename ThreadSafeDataType>
class ThreadSafeData{
   //....
private:
   ThreadSafeDataType data;
   mutex mut;
};

class apass:public ThreadSafeData<int>

Additionally, to make it unique, it might be best to make all operators and members static. For this to work you need to use CRTP i.e

template <typename ThreadSafeDataType,class DerivedDataClass>
class ThreadSafeData{
//....
};
class apass:public ThreadSafeData<int,apass>

edited Nov 09 '12 at 02:37

GManNickG

494,350
52
494
543

answered Nov 09 '12 at 01:29

Karthik T

31,456
5
68
87

1

Welcome to SO! Please don't use txt-speak in your communication, there's no need for it here and it's generally frowned upon. – GManNickG Nov 09 '12 at 02:36

J-Mik · Answer 3 · 2012-11-09T01:37:16.687

You can easily make your own class that locks the mutex on construction, and unlocks it on destruction. This way, no matter what happens the mutex will be freed on return, even if an exception is thrown, or any path is taken.

class MutexGuard
{
    MutexType & m_Mutex; 
public:

    inline MutexGuard(MutexType & mutex)
        : m_Mutex(mutex)
    { 
        m_Mutex.lock();
    };

    inline ~MutexGuard()
    { 
        m_Mutex.unlock();
    };
}


class TestClass
{
    MutexType m_Mutex;
    double m_SharedVar;

    public:
        TestClass()
            : m_SharedVar(4.0)
        { }

        static void Function1()
        {
            MutexGuard scopedLock(m_Mutex); //lock the mutex
            m_SharedVar+= 2345;
            //mutex automatically unlocked
        }
        static void Function2()
        {
            MutexGuard scopedLock(m_Mutex); //lock the mutex
            m_SharedVar*= 234;
            throw std::runtime_error("Mutex automatically unlocked");
        }

}

The variable m_SharedVar is ensured mutual exclusion between Function1() and Function2() , and will always be unlocked on return.

boost has build in types to accomplish this: boost::scoped_locked, boost::lock_guard.

Cool answer but unfortunately i said in my question i cant use boost. Otherwise i would be all over scoped mutex locks. — Fantastic Mr Fox, Nov 09 '12 at 01:35

score 1 · Answer 4 · answered Nov 09 '12 at 01:25

1

You can create a class which act as a generic wrapper around your variable synchronising the access to it.

Add operator overloading for the assignment and you are done.

answered Nov 09 '12 at 01:25

thedayofcondor

3,860
1
19
28

Some example code? Also do you mean have each of the variable types i intend to use in the one class with each function overloaded for that type. That sounds pretty messy. – Fantastic Mr Fox Nov 09 '12 at 01:27
You can create a template class which will work with any data type. – thedayofcondor Nov 09 '12 at 01:31
See @Karthik T code... my c++ is a bit rusty and wouldn't be able to write off the top of my head without an IDE...I am getting too old – thedayofcondor Nov 09 '12 at 01:33

score 1 · Answer 5 · answered Nov 09 '12 at 01:31

1

Consider use RAII idiom, below code is just the idea, it's not tested:

template<typename T, typename U>
struct APassHelper : boost::noncoypable
{
  APassHelper(T&v) : v_(v) { 
    pthread_mutex_lock(mutex_);
  }
  ~APassHelper() {
    pthread_mutex_unlock(mutex_);
  }
  UpdateAPass(T t){
    v_ = t;
  }
private:
  T& v_;
  U& mutex_;
};

double aPass;
int baPass_lock;
APassHelper<aPass,aPass_lock) temp;
temp.UpdateAPass(10);

answered Nov 09 '12 at 01:31

billz

44,644
9
83
100

this still requires users to manually use the helper, which the OP wants to avoid – Karthik T Nov 09 '12 at 01:35

score 1 · Answer 6 · answered Nov 09 '12 at 02:39

You can modify your aPass class by using operators instead of get/set:

class aPass {
public:
    aPass() {
        pthread_mutex_init(&aPass_lock, NULL);
        aPass_ = 0;
    }

    operator double () const {
        double setMe;
        pthread_mutex_lock(aPass_lock);
        setMe = aPass_;
        pthread_mutex_unlock(aPass_lock);
        return setMe;
    }

    aPass& operator = (double setThis) {
        pthread_mutex_lock(aPass_lock);
        aPass_ = setThis;
        pthread_mutex_unlock(aPass_lock);
        return *this;
    }
private:
    double aPass_;
    pthread_mutex_t aPass_lock;
};

Usage:

aPass a;
a = 0.5;
double b = a;

This could of course be templated to support other types. Note however that a mutex is overkill in this case. Generally, memory barriers are enough when protecting loads and stores of small data-types. If possible you should use C++11 std::atomic<double>.

Thread Safety Of a single variable

6 Answers6

Linked