Thread: Expert, Help please! MultiThreading in C++

The problem is that the functions that you pass as the start method are member functions of a class, and so they require a this pointer to be implicitly passed. One simple solution is to make the methods static member functions, or another solution is make them non-member functions. Another more complicated method is to make functors that store the this pointer as pThis, and then in operator() you call pThis->ReadMessage() for instance. That way if you need the class instance you have it. Or you could call a non-member function and for thread data you pass this, and then in your thread start function you just cast this pointer to the appropriate type, and call this->ReadData(). Many choices...

Well...take your pick between the methods. They all amount to the same I think. Depends on what you need. I'll show each method and give the pros and cons as I see it. By the way, I'm just rattling this code off the top of my head, so some might have minor compile errors. I changed the prototypes for the functions...I think that is the right prototype for pthread functions. Definately need to pass a void* param as data to the thread. Pretty sure that it returns an int. Try "man pthread_create" to double check the prototype.

Also, you'll need to sort out the issues with prototypes here for example 4. The compiler is going to complain because MainLoop references ControlManager before ControlManager is defined. If you don't know how to fix this with header files, then just skip example 4.

Method 1: Make the member functions static.
Pros: Easy to implement.
Cons: You don't have an instance of the object to work with. For example purposes, I added a member data "int member_data" for example purposes.

Code:

#include <pthread.h>
#include <unix.h>


class ControlManager
{
   public:
    int member_data;
     static int ReadMessage(void* data); // This function need associated as a  
                                           //thread
     static int WriteMessage(void* data);    // also a thread
     static int MainLoop(void* data);            // also a thread

     void SpawnThreads();

   private:
     pthread_t   thread1,  thread2,  thread3;
  
}

void ControlManager::SpawnThreads()
{
    pthread_create(thread1, NULL, ReadMessage, NULL);
    pthread_create(thread2, NULL, WriteMessage, NULL);
    pthread_create(thread3, NULL, MainLoop, NULL);
}

int ControlManager::ReadMessage(void* data)
{
    // data can be anything you want, passed in from the pthread_create call.
    // We don't use it here

    // This won't work!! You don't really have a this pointer, and that is the real drawback
    // this->member_data = 10;
}

Method 2: Non-member functions
Pros: Easy like first solution
Cons: Again, you don't have a this pointer

Code:

#include <pthread.h>
#include <unix.h>

/* Non-member functions */
int ReadMessage(void* data)
{

}

int WriteData(void* data)
{

}

int MainLoop(void* data)
{

}

class ControlManager
{
   public:
    int member_data;

     void SpawnThreads();

   private:
     pthread_t   thread1,  thread2,  thread3;
  
}

void ControlManager::SpawnThreads()
{
    pthread_create(thread1, NULL, ReadMessage, NULL);
    pthread_create(thread2, NULL, WriteMessage, NULL);
    pthread_create(thread3, NULL, MainLoop, NULL);
}

Method 3: Same as method 2, but pass pointer to object as parameter to pthread_create
Pros: This poniter available
Cons: No idea

Code:

#include <pthread.h>
#include <unix.h>

/* Prototypes */
int ReadData(void* data);
int WriteData(void* data);
int MainLoop(void* data);

class ControlManager
{
   public:
    int member_data;

     void SpawnThreads();

   private:
     pthread_t   thread1,  thread2,  thread3;
  
}

void ControlManager::SpawnThreads()
{
    pthread_create(thread1, NULL, ReadMessage, this);
    pthread_create(thread2, NULL, WriteMessage, this);
    pthread_create(thread3, NULL, MainLoop, this);
}

/* Non-member functions */
int ReadMessage(void* data)
{
    ControlManager* pThis = (ControlManager *)data;

    // works now
    pThis->member_data = 10;
}

int WriteData(void* data)
{
    ControlManager* pThis = (ControlManager *)data;

    // works now
    pThis->member_data = 10;
}

int MainLoop(void* data)
{
    ControlManager* pThis = (ControlManager *)data;

    // works now
    pThis->member_data = 10;
}

Fourth Method: Use functors
Pros: This pointer available, your friends think you're cool
Cons: More compilcated; someone might ask you to explain it

Code:

#include <pthread.h>
#include <unix.h>

/* Functors: */

class ReadData {
    private:
    ControlManager* pThis;

    public:

    ReadData(ControlManager* p) { pThis = p; }

    int operator()(void* data) 
    {
        pThis->member_data = 100;
    }
};

class WriteData {
    private:
    ControlManager* pThis;

    public:

    WriteData(ControlManager* p) { pThis = p; }

    int operator()(void* data) 
    {
        pThis->member_data = 100;
    }
};

class MainLoop {
    private:
    ControlManager* pThis;

    public:

    MainLoop(ControlManager* p) { pThis = p; }

    int operator()(void* data) 
    {
        pThis->member_data = 100;
    }
};

class ControlManager
{
   public:
    int member_data;

     void SpawnThreads();

   private:
     pthread_t   thread1,  thread2,  thread3;
  
}

void ControlManager::SpawnThreads()
{
    pthread_create(thread1, NULL, ReadMessage(this), NULL);
    pthread_create(thread2, NULL, WriteMessage(this),NULL);
    pthread_create(thread3, NULL, MainLoop(this), NULL);
}

You could just use Boost.Threads.

I like all my code in one class, though any of the above methods will work...

PHP Code:

#include <pthread.h>
#include <unix.h>


class ControlManager
{
public:
     void SpawnThreads();

// If you need any of these methods to be public, you probably have a conceptional oversight in your class layout
// SpawnThreads spawns the threads. If it doesn't, redo your class layout or code. 
private:
     void ReadMessage();     // This function need associated as a thread
     void WriteMessage();        // also a thread
     void MainLoop();           // also a thread

     static void ReadMessageStarter( void* );
     static void WriteMessageStarter( void* );
     static void MainLoopStarter( void* );

private:
     pthread_t thread1, thread2, thread3;
  
};

void ControlManager::SpawnThreads()
{
    pthread_create(thread1, NULL, ReadMessageStarter, this );
    pthread_create(thread2, NULL, WriteMessageStarter, this );
    pthread_create(thread3, NULL, MainLoopStarter, this );
}

void ControlManager::ReadMessage()
{
    // your thread, access to this, make sure to sync access to data
}

void ControlManager::WriteMessage()
{
    // your thread, access to this, make sure to sync access to data
}

void ControlManager::MainLoop()
{
    // your thread, access to this, make sure to sync access to data
}

void ControlManager::ReadMessageStarter( void* p )
{
    ControlManager* pThis = (ControlManager*)p;

    pThis->ReadMessage();
}

void ControlManager::WriteMessageStarter( void* p )
{
    ControlManager* pThis = (ControlManager*)p;

    pThis->WriteMessage();
}

void ControlManager::MainLoopStarter( void* p )
{
    ControlManager* pThis = (ControlManager*)p;

    pThis->MainLoop();
} 


maybe slightly off-topic, but can anybody give me any working examples of code using boost::threads? I keep comming across the same example in searches, and fixes for that broken example, but even with all different kinds of fixes people have suggested, I still can't seem to get it to work...

Thank you all for your help.

nvoigt,

Since you typecast 3 times (entry point for each thread) as:

Code:

 ControlManager* pThis = (ControlManager*)p;

Does it mean it creates three pointers point to the same object ControlManager? My concern is also about overhead .

pthis---------> ControlManager
pthis---------> ControlManager
pthis---------> ControlManager

is it three pointers or one pointer point to ControlManager object ?

Since you typecast 3 times (entry point for each thread) as:

Code:

ControlManager* pThis = (ControlManager*)p;

Does it mean it creates three pointers point to the same object ControlManager?

Yes, it does.

My concern is also about overhead .

That would be very insignificant. But if you're really concerned about it you could cast the variable every time you use it:

Code:

void ControlManager::MainLoopStarter( void* p ) 
{ 
    ControlManager* pThis = (ControlManager*)p; 

    pThis->MainLoop(); 
}

->

Code:

void ControlManager::MainLoopStarter( void* p )
{
    ((ControlManager*)p)->MainLoop();
}

Or maybe pass a variable of type ControlManager* instead of void*.

Originally Posted by dv007

Does it mean it creates three pointers point to the same object ControlManager? My concern is also about overhead.

Don't worry the cast doesn't produce any code. If its the local variable you don't like you could do it this way

Code:

void ControlManager::MainLoopStarter( void* p ) {
    ((ControlManager*)p)->MainLoop();
}

Kurt

Edit:Too late