Styjun

I'm working with an existing code base that simulates a (simple) thread scheduler and creates user threads using the Boost.Thread library.

I'm confused about a design choice from the previous developer (who is unavailable to me). For each new user thread, a ThrObjWrapper object is created; that ThrObjWrapper object contains 4 Boost threads:

• thrRun


• thrSuspend


• thrResume


• thrSleep

Whenever the thread scheduler (ThrScheduler) resumes or suspends a ThrObjWrapper, the ThrObjWrapper performs operations on 2 of these threads (which 2 vary depending on whether the scheduler is resuming or suspending the threads).

I can't figure out why so many threads are necessary. Shouldn't one boost thread be sufficient? I could even understand two threads, but four? Why four?

This is the ThrScheduler's execution loop:

// curr = the current ThrObjWrapper instance being run by the ThrScheduler

if (curr != NULL) 
 if (curr->isThrRunning()) 

 if (curr->isThrSuspended())
 curr->thrResume();

 else 
 curr->run();
 


this->sleepScheduler();

if (curr != NULL && curr->isThrRunning()) 
 curr->thrSuspend();

This is the ThrObjWrapper class (mutexes, condition variables, getters/setters etc have been removed for brevity):

class ThrObjWrapper 
 protected:
 bool suspended;

 boost::thread thrRun;
 boost::thread thrSuspend;
 boost::thread thrResume;
 boost::thread thrSleep;
;

void ThrObjWrapper::thrSuspendFunc() 
 this->thrSuspend.interrupt();
 this->thrResume.join();
 this->suspended = true;

 while (this->suspended) 
 this->thrRun.yield();
 


void ThrObjWrapper::thrSuspend() 
 this->thrSleep = boost::thread(&ThrObjWrapper::thrSuspendFunc, this);


void ThrObjWrapper::thrResumeFunc() 
 this->thrResume.interrupt();
 this->suspended = false;
 this->thrSleep.join();


void ThrObjWrapper::thrResume() 
 this->thrResume = boost::thread(&ThrObjWrapper::thrResumeFunc, this);


bool ThreadClass::isThrSuspended() 
 return this->suspended;


bool ThrObjWrapper::isThrRunning() 
 return thrRun.joinable();


void ThrObjWrapper::thrSleep(int time) 
 this->thrRun.sleep(boost::get_system_time() + boost::posix_time::milliseconds(time));


void ThrObjWrapper::run() 
 this->thrRun = boost::thread(&ThrObjWrapper::thrOperation, this);


void ThrObjWrapper::thrOperation() 
 // Performs some operation