WxWidgets multi-threading

[Adam01]

Hi, can I had some expert, detailed, and understandable advise on multi-threading please. I did google loads of stuff, but all I found was stuff on accessing GUI with threads, which Is a bit ahead of what I want to learn. (I want to learn the basic wx threading).
Help is greatly appreciated.

[weaknessforcats]

OK. Here's an overview.

1) a thread is a sequence of instructions to execute. Like main(). Instructions are executed on after another on and on through all the function calls until main is completed. Then the thread dies.
2) You can create you own threads. These are usually functions that have a specified argument list and return type. This varies by operating system. For Windows yout thread function must be:

DWORD WINAPI MyThread(LPVOID);
 

Any function of this format can be a thread.
3) You make an operating system call to create your thread and start is executing. For Windows you would use CreateThread.
4) Your thread exists until the function is complete. Then your thread dies.
5) main() and your thread do no know each other exists. If the thread and
main() use common variables, you will have big trouble unless you install a traffic light (research mutexes, critical sections).
6) your multithreaded program will run slower than your single threaded program. The time used by the thread is part of the time the OS scheduler has allowed for your main(). This will vary by the CPU in your machine. It will also vary by using multiple cores. This part gets deep.
7) you can talk to your thread from main() by using and event.
8) the more threads the slower it goes.
9 creating a thread is not the same a creating a child process. This is a wole other area.

If you are using Windows, read Windows via C/C++ Jeffrey Richter 2007. Multithreading is covered in great detail.

Good luck.

[Adam01]

Thanks, I'l look into it, I do know multithreading with _beginthread(), but being in a wxWidgets app is a bit more complicated.

[weaknessforcats]

Not really.

What you do is define a class member function to launch the thread.

Inside this function you call a static class member function, which is the actual thread.

What you is define a class static member function. Since this function requires no object you can use it to start your thread.

Inside launch member function you call _beginthread() using this as the argument for the thread and use a static class method for the actual thread. When this static method returns, the thread is complete and dies.

Now you have passed the this pointer as the argument to _beginthread().

int _beginthread(
    register void ( *start_address)(void *),  <--your class static function name
    void *stack_bottom,
    unsigned stack_size,
    void *arglist );                  <-the this pointer of the object starting the thread
 

Inside the static member function (which is the thread) you typecast the arglist back to the class type that launched the thread. That is, a reinterpret_cast of arglist to the class name containing the static funciton.

Now you can use the typecast pointer to call member functions on the object.

[Adam01]

I havnt got time to test this at the moment, but doing this, would not return a type match error? something like:
"(void (*) makethread(void)) does not match (frameclass:: makethread(void*)"

[weaknessforcats]

"(void (*) makethread(void)) does not match (frameclass:: makethread(void*)"

All threads need the same function prototype. Look at my previous post:

int _beginthread(
    register void ( *start_address)(void *),  <--your class static function name
    void *stack_bottom,
    unsigned stack_size,
    void *arglist );                  <-the this pointer of the object starting the thread
 

Your thread function must take a void* argument and return void. No other function can be used. That means void (*) makethread(void) cannot be used as a pointer to a thread function because it does not have a void* argument.

[Adam01]

Ok, what about calling other stuff from the static thread, like:

void frameclass::startthread(void*){
thread();
}
 
int frameclass::thread(){
wxThing * wxobject = wxThing1;
wxobject->SetValue(...);
}

Just to make sure, that would all be ok if called by the thread starter?
Thanks for your help as well.

[weaknessforcats]

void frameclass::startthread(void*){
thread();
}

int frameclass::thread(){
wxThing * wxobject = wxThing1;
wxobject->SetValue(...);
}

The void* argument is the this pointer of the frameclass object that was used to create this thread. You now cast the void* to a frameclass* and go from there:

void frameclass::startthread(void* arg){
reinterpret_cast<frameclass*> (arg)->thread();
}
 
int frameclass::thread(){
wxThing * wxobject = wxThing1;
wxobject->SetValue(...);
}
 

When frameclass::thread() is complete then frameclass::startthread() will be complete and the thread dies. Remember, as far as your program is concerned, frameclass::startthread is the thread. That typecast just gets you back to being able to call your class methods again.

[Adam01]

Ok, I see now, I havnt used the < > stuff yet.

[Adam01]

oh yes!, It works!
Thanks a million weaknessforcats.