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?

Answer 1

std::atomic<double> aPass;

provided you have C++11.