Correct Termination Of A Thread

Good day everyone. I have a general question relating to threads and the necessary steps to correctly "shutdown" a thread.

Just quick pseudocode:

Code:

---

HANDLE thread;

thread = CreateThread(task1);

WaitForSingleObject(thread);

closeHandle(thread);    <--------

thread = CreateThread(task2);


DWORD task1() <--- Thread routine 1.
DWORD task2() <--- Thread routine 2.

---

The line pointed to by the red arrow. Is this required before using the same handle object to create another thread? Or can this call be omitted and just called once upon program termination? Basically wondering about the leaking of GDI resources.

Thanks.

Oh I was also wondering. I am quite often shutting down the thread and re-creating it using another processing routine. (Note: Each processing routine does not run in parallel) Should I constantly be shutting down the thread and creating it or just have multiple threads that never shutdown (just suspend) one for each routine or just try and use the one thread to try and handle all routines in there so it lasts the lifetime of the program.? Sorry if this question sounds confusing.

Quote:

---

Is [the line with the red arrow] required before using the same handle object to create another thread?

---

Probably. The assignment would discard whatever thread the previous handle was referencing. The only way this could be freed would be at the end of your program, and even then you might not want to rely on that.

You could always create test programs -- one of each, CloseHandle() and no CloseHandle() -- and monitor their GDI resources allocated.

Quote:

---

Oh I was also wondering. I am quite often shutting down the thread and re-creating it using another processing routine. (Note: Each processing routine does not run in parallel) Should I constantly be shutting down the thread and creating it or just have multiple threads that never shutdown (just suspend) one for each routine or just try and use the one thread to try and handle all routines in there so it lasts the lifetime of the program.? Sorry if this question sounds confusing.

---

Well, since the code does not run in parallel, why would you want to use threads at all?

Anyway, starting and stopping threads would use less memory than starting them all at once. But starting them all at once might be faster.

Having only one thread would be ideal, of course. But it might be difficult to implement.

BTW, if you plan on using the C standard library at all in your program, consider using _beginthread() or _beginthreadex() instead of CreateThread(). We had a topic about this kind of thing in the C section regarding Windows Threads.

Edit: Here's the topic: http://cboard.cprogramming.com/showthread.php?t=91620

Thread handles aren't GDI resources. They are kernel resources.

You must call CloseHandle on every kernel handle created. This includes the return value of CreateThread. Otherwise, you leak the thread descriptor.

Don't use __beginthread. It's conceptually broken. Always use __beginthreadex.

Better yet, use Boost.Thread.

Each Win API function allocating some resource like handle explicetly specifies what function should be called to free the resourse... You just need to read the function reference and follow the requirements...

And BTW - if you do not need the thread handle for any reasn - you can close the handle just after the creating the thread, it will not terminate the thread - just free the resource allocated in the main thread, child thread will free its own resources when it is finished...

Of course freeing the Handle in such a manner will prevent you from waiting till the thread termination and retreiving the return value of the thread - for example.

Quote:

---

Originally Posted by vart

And BTW - if you do not need the thread handle for any reasn - you can close the handle just after the creating the thread, it will not terminate the thread - just free the resource allocated in the main thread, child thread will free its own resources when it is finished...

---

Woah, now that I have never heard of before. I was assuming the handle was directly linked to the thread execution.... Very useful to know.