Question

My application is divided into some smaller domains and in order to reduce the dependencies between them I am going to use context object. Let’s consider a simple example:

class SomeType1;
class SomeType2;    
class dummy;

//context for first domain
class foo
{
public:
    virtual void setPtr1 (SomeType1* val) = 0;
    virtual SomeType2* getPtr2 () = 0;

    static foo* getCTX()
    {
        //statement bellow is a singleton which creates one instance of dummy and
        //returns its address as foo*
        return AppCTX::AccessorType<dummy>::getCTX<foo>();
    }
    virtual ~foo();
};

//context for second domain
class bar
{
public:
    virtual void setPtr2 (SomeType2* val) = 0;
    virtual SomeType1* getPtr1 () = 0;
    static bar* getCTX()
    {
         //same as above but casts dummy* to bar*
         return AppCTX::AccessorType<dummy>::getCTX<bar>();
    }
    virtual ~bar();
};

//dummy is a singleton created in AppCTX::AccessorType<dummy>
class dummy: public foo, public bar
{
public:
    virtual void setPtr1 (SomeType1* val)
    {
         ptr1 = val;
    }

    virtual SomeType1* getPtr1 ()
    {
         return ptr1;
    } 

    virtual void setPtr2 (SomeType2* val)
    {
         ptr2 = val;
    }

    virtual SomeType2* getPtr2 ()
    {
         return ptr2;
    } 
    virtual ~dummy();
private:
    SomeType1* ptr1;
    SomeType2* ptr2;
};

My domains starts multiple threads which use context also so ptr1 and ptr2 may be accessed in parallel. Do I need to synchronize setPtrs and getPtrs with mutexes? Is there any chance that ptr1 and ptr2 may get corrupted somehow?

Answer 1

It isn’t going to be very valuable to mutex your getPtr and setPtr functions. Even after the caller obtains the pointer and releases the mutex, it can still do whatever it wants to with the pointer it received. This could definitely cause problems with multiple threads.

You actually want to put your locking mechanisms in the SomeType1 and SomeType2 classes themselves. For instance, you might acquire a mutex at the beginning of each member function of SomeType1 and then release the mutex before each member function returns.

Some of your member functions may already be thread-safe. For instance, if they don’t access member variables or any other shared resources, then there isn’t any possibility of contention between threads. So, you wouldn’t have to mutex those. But you will need to look at each of your member functions and ask yourself what would happen if the member variables used by those functions changed unexpectedly. If the behavior would be undesirable, then that member function should be mutexed.

But if what you are worried about is the actual pointer variables themselves getting corrupted, it depends on the machine architecture you are compiling for. For many systems (for which the assignment of a 32-bit pointer is an atomic operation) this won’t be an issue at all. That question is answered more fully here.