windows多线程 - 初级

creating threads in VC++ is simple and fast.

first of all, you need a HANDLE, you will use this HANDLE to "handle" the thread,

just like the way you "handle" a file, a socket, a device, etc.

somewhere you need spawn a new thread // DWORD thread_id; HANDLE hThread = CreateThread(NULL, 0, function_name, function_argument, 0, &thread_id);  

If you don't care about the thread_id, you can use NULL instead.

At last, the thread function must be this prototype:

return value DWORD, one parameter, type: LPVOID

if the function is in a class, the function need to be a static one, however, there is a workaround, talk about it later.

an example thread function

DWORD thread_function(LPVOID func_arg){ // use your argument and the thread has been running... your_type arg = (your_type)func_arg; printf("Hey, I'm running in a new thread./n"); pritnf("And, my thread id is: %d/n", GetCurrentThreadId()); printf("Bye-bye, this thread is going to be dead soon./n"); return 0; } 

this way, you have created a thread, and the thread is executing the function_name function with the argument you provided

in the function "function_argument". the thread_id will be the thread id of the created thread.

OK, what if you want to use a member function inside a class?

if you want to execute a member function, you can do this, it is a little tricker, but in fact, it is very easy to use, don't be scared by these at first,

template <typename C> struct ThreadInfo{ // we have an object C* obj; // and that object has a function that takes void* and returns DWORD, and so is suitable for a threadproc (except for it being a member function) DWORD (C::* function)(void*); // and we have any amount of extra data that we might need. void* data; // default copy c-tor, d-tor and operator= are fine ThreadInfo(C* o, DWORD (C::*func)(void*), void* d) : obj(o), function(func), data(d) { } }; template <typename C> DWORD WINAPI createThreadFunction(void* data){ std::auto_ptr<ThreadInfo<C> > ti((ThreadInfo<C>*)data); return ((ti->obj)->*(ti->function))(ti->data); } template <typename C> void* createThreadInfo(C* o, DWORD(C::* f)(void*), void* d){ return (void*)new ThreadInfo<C>(o, f, d); } 

these are called template, it is a very power tool in C++, however, you don't need to worry about these at all for now, all you need to do is, copy and paste these fuzzy code to somewhere in your code, but donot paste them into a class :)

I never tried these...in face, this template was stealed from a bbs, thx him for the sharing, it's very helpful

and, when you want to use a member function to create a thread, do this:

Let's say the class name is MyClass, and the object is myObj, if the call is inside another member function of MyClass,

you can also use "this" as the object reference.

MyClass myObj; // the object to create a thread ArgType an_arg; // an argument DWORD thread_id; HANDLE thread_handle = CreateThread(NULL, 0, createThreadFunction<MyClass>, createThreadInfo<MyClass>(&myObj, &MyClass::a_function, &an_arg), 0, &thread_id); if(thread_handle == INVALID_THREAD ){ // Always do check printf("Failed to create a thread. Error code: %d/n", GetLastError()); return -1; } // OK, the thread is running now... 

of course, the a_function also need to be match the thread function prototype, such as

DWORD MyClass::a_function(LPVOID t_arg){ // anything you want to do... return 0; }  

This is almost everything about threading in Windows.

(OK. I'm lying...there ARE much MORE:D, and do threading right is very HARD.)

Go threading, but don't go too far for now. 你懂的

cheer up.