CODEWITHSUNDEEP
c++multithreading
rbhkamal
rbhkamal

Reputation: 155

Best way to protect a callback function from deconstructed classes

What would be a good/best to ensure thread safety for callback objects? Specifically, I'm trying to prevent a callback object from being deconstructed before all the threads are finished with it.

It is easy to code the client code to ensure thread safety, but I'm looking for a way that is a bit more streamlined. For example, using a factory object to generate the callback objects. The trouble then lies in tracking the usage of the callback object.

Below is an example code that I'm trying to improve.

class CHandlerCallback
{
public:
     CHandlerCallback(){  ...  };
     virtual ~CHandlerCallback(){  ...  };
     virtual OnBegin(UINT nTotal ){  ...  };
     virtual OnStep (UINT nIncrmt){  ...  };
     virtual OnEnd(UINT nErrCode){  ...  };

protected:
      ...
}

static DWORD WINAPI ThreadProc(LPVOID lpParameter)
{
    CHandler* phandler = (CHandler*)lpParameter; 
    phandler ->ThreadProc();
    return 0;
};

class CHandler
{
public:
    CHandler(CHandlerCallback * sink = NULL) {
        m_pSink = sink;
        // Start the server thread. (ThreadProc)
    };
    ~CHandler(){...};

    VOID ThreadProc(LPVOID lpParameter) {
       ... do stuff
       if (m_pSink) m_pSink->OnBegin(..)
       while (not exit) {
           ... do stuff
           if (m_pSink) m_pSink->OnStep(..)
           ... do stuff
       }
       if (m_pSink) m_pSink->OnEnd(..);
    };

private:
    CHandlerCallback * m_pSink;
}

class CSpecial1Callback: public CHandlerCallback
{
public:
     CSpecial1Callback(){  ...  };
     virtual ~CBaseHandler(){  ...  };
     virtual OnStep (UINT nIncrmt){  ...  };
}

class CSpecial2Callback: public CHandlerCallback...

Then the code that runs everything in a way similar to the following:

int main {
   CSpecial2Callback* pCallback = new CSpecial2Callback();
   CHandler handler(pCallback );
   // Right now the client waits for CHandler to finish before deleting
   // pCallback 
}

Thanks!

Upvotes: 0

Views: 443

Answers (1)

Pyrce
Pyrce

Reputation: 8571

If you're using C++11 you can use smart pointers to keep the object around until the last reference to the object disappears. See shared_pointer. If you're not in C++11 you could use boost's version. If you don't want to include that library and aren't in C++11 you can resort to keeping an internal count of threads using that object and destroy the object when that count reaches 0. Note that trying to track the counter yourself can be difficult as you'll need atomic updates to the counter.

shared_ptr<CSpecial2Callback> pCallback(new CSpecial2Callback());
CHandler handler(pCallback); // You'll need to change this to take a shared_ptr
... //Rest of code -- when the last reference to 
... //pCallback is used up it will be destroyed.

Upvotes: 1

Related Questions