Pthread in c++ class

In pthread API, the pthread_create() takes function which takes a generic pointer and returns a generic pointer. Here is a sample pthread implementation in c

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>

//thread callback function
void* thread_func(void *arg)
{
   char *msg = (char*)arg;
   fprintf(stdout,"In thread....\n");
   sleep(1);
   fprintf(stdout, "Message : %s\n", msg);
   sleep(1);
   fprintf(stdout, "Thread exiting...\n");
   return NULL;
}


int main()
{
   pthread_t tid;
   int rc = 0;
   char *msg = "Hello";
   
   rc = pthread_create(&tid, NULL, thread_func, (void*)msg);
   if ( rc != 0)
   {
      fprintf(stderr, "Thread creation failed\n");
      fprintf(stderr, "%s\n",strerror(rc));
      exit(EXIT_FAILURE);
   }

   rc = pthread_join(tid, NULL);
   if ( rc != 0)
   {   
      fprintf(stderr, "Thread creation failed\n");
      fprintf(stderr, "%s\n",strerror(rc));
      exit(EXIT_FAILURE);
   }   

   return 0;
}

Output:-

In thread....
Message : Hello
Thread exiting...

The problem with pthread_create in c++ is that it can't take member function as a thread function. Because, pthread_create expects a normal function, not a c++ member function. If we pass a member function, then the implicit this pointer won't be available inside this, hence the purpose of member function won't be fulfilled. For this reason, we need to make the thread function static and pass this pointer as object. Inside the function, everything should be accessed through the this pointer. Here is a sample code of pthread_create in C++

#include <iostream>
#include <string>

extern "C"
{
#include <pthread.h>
#include <string.h>
#include <stdlib.h>
}

using namespace std;


class MyThread
{
   string strMsg;
   pthread_t Tid;

public:
   MyThread(string strMsg):strMsg(strMsg) { }

   //Callback function for thread
   static void* thread_func(void *pThisArg)
   {
      //This pointer is passed as an argument
      MyThread *pThis = static_cast<MyThread*>(pThisArg);
      pThis->Run();
      return NULL;
   }

   void CreateThread()
   {
      int rc = pthread_create(&Tid, NULL, thread_func, static_cast<void*>(this));
      if ( rc != 0 )
      {
         cerr<<"Error in thread creation..."<<endl;
         cerr<<strerror(rc)<<endl;
         exit(EXIT_FAILURE);
      }
   }

   void JoinThread()
   {
      int rc = pthread_join(Tid, NULL);
      if ( rc != 0 )
      {
         cerr<<"Error in thread join...."<<endl;
         cerr<<strerror(rc)<<endl;
         exit(EXIT_FAILURE);
      }
   }

   void Run() 
   {
      cout<<"In Thread..."<<endl;
      sleep(1);
      cout<<"Message : "<<strMsg<<endl;
      sleep(1);
      cout<<"Thread exiting..."<<endl;
   }

};

int main() 
{
   MyThread ThreadOb("Hi Hi");
   ThreadOb.CreateThread();
   ThreadOb.JoinThread();
   return 0;
}

Output:-

In Thread...
Message : Hi Hi
Thread exiting...

Here, the problem is we need to write a static member function for every class that needs to use pthread_create(). I have made a wrapper class for this. Here is the code along with how to use it.

/*
* Copyright 2012 Asit
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

#include <iostream>
#include <string>

extern "C" 
{
#include <pthread.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
}

using namespace std; 


//Abstract Class responsible for creating and lunching thread

class AbstractThread 
{

public:
   
   AbstractThread():m_pThreadArg(NULL) { }   
   ~AbstractThread() 
   { 
      if ( m_pThreadArg != NULL )
         delete m_pThreadArg;
   }

   //Concrete Class needs to implement the method Process()   
   virtual void Process() = 0;
   
   //Start() should be called to create the thread and execute the method Process()
   void Start() 
   {
      int iRetVal = 0;

      m_pThreadArg = new ThreadParamType;
      m_pThreadArg->m_pThis = this;
      m_pThreadArg->m_pThreadFun = &AbstractThread::Process;
      iRetVal = pthread_create(&m_ThreadId,   //Thread Id
                               NULL,          //Thread Attribute Object
                               &AbstractThread::CallThreadFunc,  //Thread Function
                               static_cast<void*>(m_pThreadArg)  //Argument to thread func
                              );
      if ( iRetVal != 0 ) 
      {
         cerr<<"Error in thread creation.."<<endl;
         cerr<<strerror(iRetVal)<<endl;
         exit(EXIT_FAILURE);
      }
   }
   
   //Join() should be called to wait for the thread to finish
   void Join()
   {
      int iRetVal = 0;
      iRetVal = pthread_join(m_ThreadId, NULL);
      if ( iRetVal != 0 )
      {
         cerr<<"Error in thread join.."<<endl;
         cerr<<strerror(iRetVal)<<endl;
         exit(EXIT_FAILURE);
      }
   }
   
private:

   //ThreadParamType contains a pointer (m_pThis) to AbstractThread object 
   //and a member function pointer (m_pThreadFun) which will be called by
   //static function CallThreadFunc()
   struct ThreadParamType 
   {   
      AbstractThread *m_pThis;
      void (AbstractThread::*m_pThreadFun) (void);    
   };  

   pthread_t m_ThreadId;
   pthread_attr_t m_Attribute;
   ThreadParamType *m_pThreadArg;

private:
   //CallThreadFunc is the callback function which is executed in the new thread
   //Expects a pointer to ThreadParamType object.
   static void* CallThreadFunc(void *pArg) 
   {
      ThreadParamType *pThreadParam = static_cast<ThreadParamType *>(pArg);
      void (AbstractThread::*pMemberFunc) (void);
      AbstractThread *pThis = pThreadParam->m_pThis;
      pMemberFunc = pThreadParam->m_pThreadFun;
      ((*pThis).*pMemberFunc)();
      return NULL;
   }   
};


class ConcreteThread : public AbstractThread 
{

public:
   ConcreteThread(string strMsg):strMsg(strMsg) {}
   ~ConcreteThread() {}

   //Mandatory to implement Process()
   void Process() 
   {
      cout<<"In Thread..."<<endl;
      sleep(1);
      cout<<"Message : "<<strMsg<<endl;
      sleep(1);
      cout<<"Thread exiting..."<<endl;
   }
private:
   string strMsg;

};     


int main() 
{

   ConcreteThread Ob("Ho Ho");
   Ob.Start();
   cout<<"Control in Main"<<endl;
   Ob.Join();
   
   return 0;
}

Output

Control in Main
In Thread...
Message : Ho Ho
Thread exiting...