Threaded Functions

tag:blogger.com,1999:blog-3330363568531008511.post-31505100533119351882007-04-26T12:12:00.000-07:002007-04-26T13:07:19.552-07:00Threaded FunctionsHere's an interesting thought experiment for functions that get executed in a separate thread. <pre> void doit( int i ) { printf( "Hello from doit! i: %d\n", i ); } void doit2( Thread* th, int i ) { printf( "Hello from doit2! i: %d, th: %p, tid: 0x%04x \n", i, th, th->getThreadID() ); } class Snarfy { public: void thisBlows( int g ) { printf( "Hello from thisBlows! i: %d, this ptr: %p\n", g, this ); } }; class Swanky { public: void doit( double& d, const String& s ) { printf( "Hello from Swanky::doit! d: %0.3f, s: %s, this ptr: %p\n", d, s.ansi_c_str(), this ); } void doit2( Thread* th, double& d, const String& s ) { printf( "Hello from Swanky::doit! d: %0.3f, s: %s, this ptr: %p\n", d, s.ansi_c_str(), this ); for (int i=0;i<10;i++){ th->sleep(1000); } } }; int main( int argc, char** argv ){ FoundationKit::init( argc, argv ); Thread* th = ThreadedProcedure1<int>(10,doit); th->wait(); th = ThreadedProcedure1<int>(231,doit2); th->wait(); Snarfy sn; th = ThreadedProcedure1<int,Snarfy >(&sn,38112,&Snarfy::thisBlows); th->wait(); String s = "hello"; Swanky sk; double d = 0.0332; th = ThreadedProcedure2< double&,const String&, Swanky >(&sk,d,s,&Swanky::doit2); th->wait(); printf( "Bye!\n"); FoundationKit::terminate(); return 0; } </pre> The actual implementation gets a bit long winded, but looks something like this: <pre> template <typename ParamType1> class NullClassType1 { public: void m(ParamType1){} void m(Thread*, ParamType1){} }; template <typename ParamType1, typename ClassType=NullClassType1<ParamType1> > class ThreadedProcedure1: public Runnable { public: typedef NullClassType1<ParamType1> NullClassType; typedef void (*ProcPtr1)(ParamType1 p1); typedef void (*ProcThreadPtr1)(Thread* thread, ParamType1 p1); typedef void (ClassType::*ClassProcPtr1)( ParamType1 p1 ); typedef void (ClassType::*ClassThreadProcPtr1)( Thread* thread, ParamType1 p1 ); ThreadedProcedure1( ParamType1 p1, ProcPtr1 procPtr ): param1_(p1), runningThread_(NULL), procPtr_(NULL), procThreadPtr_(NULL), classProcPtr_(NULL), classThreadProcPtr_(NULL), instancePtr_(NULL){ ThreadedProcedure1<ParamType1,ClassType>* params = new ThreadedProcedure1<ParamType1,ClassType>(p1); params->procPtr_ = procPtr; runningThread_ = new Thread( params, true, true ); params->runningThread_ = runningThread_; runningThread_->start(); } ThreadedProcedure1( ParamType1 p1, ProcThreadPtr1 procPtr ): param1_(p1), runningThread_(NULL), procPtr_(NULL), procThreadPtr_(NULL), classProcPtr_(NULL), classThreadProcPtr_(NULL), instancePtr_(NULL){ ThreadedProcedure1<ParamType1,ClassType>* params = new ThreadedProcedure1<ParamType1,ClassType>(p1); params->procThreadPtr_ = procPtr; runningThread_ = new Thread( params, true, true ); params->runningThread_ = runningThread_; runningThread_->start(); } ThreadedProcedure1( ClassType* src, ParamType1 p1, ClassProcPtr1 procPtr ): param1_(p1), runningThread_(NULL), procPtr_(NULL), procThreadPtr_(NULL), classProcPtr_(NULL), classThreadProcPtr_(NULL), instancePtr_(NULL) { ThreadedProcedure1<ParamType1,ClassType>* params = new ThreadedProcedure1<ParamType1,ClassType>(p1); params->classProcPtr_ = procPtr; params->instancePtr_ = src; runningThread_ = new Thread( params, true, true ); params->runningThread_ = runningThread_; runningThread_->start(); } ThreadedProcedure1( ClassType* src, ParamType1 p1, ClassThreadProcPtr1 procPtr ): param1_(p1), runningThread_(NULL), procPtr_(NULL), procThreadPtr_(NULL), classProcPtr_(NULL), classThreadProcPtr_(NULL), instancePtr_(NULL){ ThreadedProcedure1<ParamType1,ClassType>* params = new ThreadedProcedure1<ParamType1,ClassType>(p1); params->classThreadProcPtr_ = procPtr; params->instancePtr_ = src; runningThread_ = new Thread( params, true, true ); params->runningThread_ = runningThread_; runningThread_->start(); } protected: ThreadedProcedure1( ParamType1 p1 ): param1_(p1), runningThread_(NULL), procPtr_(NULL), procThreadPtr_(NULL), classProcPtr_(NULL), classThreadProcPtr_(NULL), instancePtr_(NULL){ } public: virtual bool run() { if ( typeid(ClassType) == typeid(NullClassType) ) { if ( NULL != procThreadPtr_ ) { (*procThreadPtr_)( runningThread_, param1_ ); } else if ( NULL != procPtr_ ) { (*procPtr_)( param1_ ); } else { return false; } } else { if ( NULL != instancePtr_ ) { if ( NULL != classThreadProcPtr_ ) { (instancePtr_->*classThreadProcPtr_)( runningThread_, param1_ ); } else if ( NULL != classProcPtr_ ) { (instancePtr_->*classProcPtr_)( param1_ ); } else { return false; } } } return true; } virtual void stop(){} operator Thread* () { return runningThread_; } protected: ParamType1 param1_; Thread* runningThread_; ProcPtr1 procPtr_; ProcThreadPtr1 procThreadPtr_; ClassProcPtr1 classProcPtr_; ClassThreadProcPtr1 classThreadProcPtr_; ClassType* instancePtr_; }; </pre> This allows us to attach a function and execute it in a separate thread, using the various VCF thread classes, such as <a href="http://vcf-online.org/docs/src_manual/classVCF_1_1Thread.html">VCF::Thread</a> and <a href="http://vcf-online.org/docs/src_manual/classVCF_1_1Runnable.html">VCF::Runnable</a> to implement it. I'll leave it as an exercise for the reader to add additional arguments. If people like this enough we'll probably put this into the FoundationKit proper.<div class="blogger-post-footer"><img width='1' height='1' src='https://blogger.googleusercontent.com/tracker/3330363568531008511-3150510053311935188?l=software-windmills.blogspot.com'/></div>Jim Craftonhttp://www.blogger.com/profile/06342609230425703376noreply@blogger.com0