CODEWITHSUNDEEP
multithreadingc++11thread-safetyfunction-pointersmember
DarioP
DarioP

Reputation: 5465

Thread safety of a member function pointer

A class t_analyser contains a function which performs some operations on a t_data object and outputs the results.

I would like to add to t_analyser a filter capability: a small and fast function

bool filter(const t_data & d) {...}

which allows to skip the analysis (and the output) if some conditions are met for that particular data. The filter should be setted up easily from the main, so I was thinking to store a shared function pointer in t_analyser and use a lambda to initialize it.

Is this a good approach? My concerns are related to the fact that many analysers can call the same filter function simultaneously in different threads, could this be a problem? Can I simply copy the pointer in the t_analyser's copy constructor? Any hint would be much appreciated.

Upvotes: 0

Views: 268

Answers (3)

egur
egur

Reputation: 7970

You can declare the function pointer as static + thread specific:

static _declspec(thread) FUNC_TYPE filterFunc;

Each thread that modifies filterFunc works on a different copy of the pointer.

Upvotes: 0

Andriy Tylychko
Andriy Tylychko

Reputation: 16276

This could be a problem if your filter function had side effects. Its signature is simple and says that it just makes some decision reading data from t_data, so make sure that t_data is not modified in parallel thread and you'll be fine.

Upvotes: 1

Werner Erasmus
Werner Erasmus

Reputation: 4076

Consider the following program:

#include <iostream>

struct X
{
    void foo1(){ std::cout << "foo1" << std::endl; }
    void foo2(){ std::cout << "foo2" << std::endl; }
};

typedef void (X::*MemberFunctionPointer)();

struct ByRef
{
    ByRef( MemberFunctionPointer& f )
      : f_( f )
    {
    }
    void operator()()
    {
      X x;
      (x.*f_)();
    }
    MemberFunctionPointer& f_;
};

struct ByValue
{
    ByValue( MemberFunctionPointer f )
      : f_( f )
    {
    }
    void operator()()
    {
      X x;
      (x.*f_)();
    }
    MemberFunctionPointer f_;
};

int main()
{
  MemberFunctionPointer p = &X::foo1;
  ByRef byRef( p );
  ByValue byValue( p );
  byRef();
  byValue();

  p = &X::foo2;
  byRef();
  byValue();
  return 0;
}

Output:

foo1
foo1
foo2
foo1
Press <RETURN> to close this window...

From this you will notice that in the one case the member function pointer is passed by value (and not shared), and in the other it is passed by reference (and shared). When using the syntax:

foo( void( X::*f)() )...

the pointer to member function is passed by value, and is copied (and cannot be modified) again.

Upvotes: 0

Related Questions