Creating an Object-Oriented Wrapper to Windows Threads

Thread Definition

Working with Windows Threads

HANDLE CreateThread(
 LPSECURITY_ATTRIBUTES lpThreadAttributes, // Security Descriptor
 DWORD dwStackSize,                        // initial stack size
 LPTHREAD_START_ROUTINE lpStartAddress,    // thread function
 LPVOID lpParameter,                       // thread argument
 DWORD dwCreationFlags,                    // creation option
 LPDWORD lpThreadId                        // thread identifier
);

DWORD WINAPI ThreadProc(
  LPVOID lpParameter   // thread data
);

Rest of the parameters to CreateThread function will be ignored for now.

Our task is to build an object oriented wrapper class using these functions, since we know they are enough to create a thread.

Lets now create a class called ThreadClass. Every object of ThreadClass will represent a unique thread. Also it will have methods to create and manage that thread. It has to be noted that whenever we create a new thread, we get a process-wide identifier for that thread called Thread Handle. This handle will be useful for us in managing the thread. So, the threads handle will become an unavoidable member of the class. Apart from that, we will have a Boolean variable to indicate the state of the thread. Now our class looks like this.

class ThreadClass 
{
public:
 ThreadClass(){}
 virtual ~ThreadClass(){Kill();}

 //Thread Management
 bool CreateNewThread();
 bool Wait(); //Wait for thread to end
 bool Suspend(); //Suspend the thread
 void Resume(); //Resume a suspended thread
 bool Kill(); //Terminate a thread
 bool IsActive(); //Check for activity

 //override these functions in the derived class 
 virtual void ThreadEntry(){ }
 virtual void ThreadExit(){ }
 virtual void Run(){ }

 //a friend
 friend DWORD  WINAPI _ThreadFunc(LPVOID  pvThread);

protected:
 HANDLE m_hThread; //Thread handle
 bool m_bActive; //activity indicator
 DWORD m_lpId; //Thread ID
};

One of the things that need explanation is the _ThreadFunc function. This is a friend function to the class. We will know about the details of this function later. This class has almost all the functions that are necessary to manage a thread. We will know the three virtual functions in the middle ThreadEntry, Run and ThreadExit very soon.

Lets now discuss about the friendly function; this function will be responsible for creating the illusion of thread as an object.

//Friend of Thread class
//Actual thread around which the OO wrapper is built.
//Do not call twice on the same object.
//do something (initializing and finalizing) in ThreadEntry and ThreadExit functions.
DWORD  WINAPI _ThreadFunc(LPVOID  pvThread)
{
 ThreadClass* pThread = (ThreadClass*)pvThread;  //typecast

 pThread->ThreadEntry(); //initialize
 pThread->Run();
 pThread->ThreadExit(); //finalize
}

Now we know that this function is the actual thread of execution, lets see how to create the thread. This function just creates a new thread and stores the Id in m_hThread, which will be used to manage the thread. When this function is called, it calls the win32 function CreateThread with the address of _ThreadFunc function and passes the this pointer as the function parameter.

Now lets go back to the _ThreadFunc. This function after typecasting the parameter to ThreadClass type, calls ThreadEntry, Run and ThreadExit functions. Now in your derived class (from Thread), you will over-ride these three functions, so they get called. And bingo, there is our Thread class working.

bool ThreadClass::CreateNewThread()
{
 m_hThread = CreateThread(NULL, 
                          0, 
                          (LPTHREAD_START_ROUTINE)_ThreadFunc, 
                          (LPVOID) this, 
                          0, 
                          (LPDWORD) &m_lpId);

 if(m_hThread == NULL)
  return false;

 bActive = true;
 return true;
}

bool ThreadClass::Suspend()
{
 bActive = false;
 return(-1 != SuspendThread(m_hThread));//win32 API         
}

bool ThreadClass::Kill()
{
 return BOOL TerminateThread(m_hThread, 1); //win32 API
}
 
bool ThreadClass::Resume()
{
 bActive = true;
 return(-1 != ResumeThread(m_hThread)); //win32 API
}

bool ThreadClass::Wait()
{
 return (WAIT_OBJECT_0 
         == WaitForSingleObject(m_hThread, INFINITE)); 
 //win32 API
}

bool ThreadClass::IsActive()
{
 return m_bActive;
}

The above class doesnt use any of the synchronization primitives.

Now to using our class, just the way you create an object of CWinThread, you will create an object of this class and call CreateNewThread and bingo, you have a new thread running for you. But remember to over ride the Run member function of this class.

class MyThread :: public ThreadClass
{
 virtual void ThreadEntry()
 {
  //Initialize
 }

 virtual void ThreadExit()
 {
  //Finalize
 }

 virtual void Run()
 {
  //do something
 }
};

Main()
{
 MyThread newThread;
 newThread.CreateNewThread();

 //One Some condition
 newThread.Suspend();

 //Some other condition
 newThread.Resume();

 //An Exception?
 newThread.Kill();

 //finally
 newThread.Wait();
}

Thus we have created a wrapper around windows threads and shielded the user from the intricacies of creating and using threads in the raw form. This class can be extended and used in the way as shown above.