Is it necessary to explicitly stop all threads prior to exiting a Win32 application?

Yes, you have to if you are simply exiting or terminating the main thread via ExitThread or TerminateThread, otherwise your application may not fully shutdown. I recommend reading Raymond Chen's excellent blog posts on this topic:

• The old-fashioned theory on how processes exit
• Quick overview of how processes exit on Windows XP
• How my lack of understanding of how processes exit on Windows XP forced a security patch to be recalled
• During process termination, the gates are now electrified
• If you return from the main thread, does the process exit?

But please note in particular that if you properly return from the main or WinMain function, the process will exit as described by the ExitProcess API documentation and the last post by Raymond Chen that is being linked above!

The short of it is:For a native Win32 process to terminate, one of two conditions must be met:

• Someone calls ExitProcess or TerminateProcess.
• All the threads exit (by returning from their ThreadProc (including the WinMainEntryPoint that is the first thread created by windows)), close (by calling ExitThread), or terminated (someone calls TerminateThread).

(The first condition is actually the same as the 2nd: ExitProcess and TerminateProcess, as part of their cleanup, both call TerminateThread on each thread in the process).

The c-runtime imposes different conditions: For a C/C++ application to terminate, you must either:

• return from main (or WinMain).
• call exit()

Calling exit() or returning from main() both cause the c-runtime to call ExitProcess(). Which is how c & c++ applications exit without cleaning up their threads. I, personally, think this is a bad thing.

However, non trivial Win32 processes can never terminate because many perfectly, otherwise reasonable, Win32 subsystems create worker threads. winsock, ole, etc. And do not provide any way to cause those threads to spontaneously close.

No, when WinMain returns, the process will be terminated, and this means all threads spawned by the process should be terminated though they might not be closed gracefully.

However, it is possible that a primary thread is terminated while the other threads are running, resulting in the application is still running. If you call ExitThread (not exit or ExitProcess) in WinMain, and there are running threads (eventually created by the primary thread), then, you may observe this behavior. Nonetheless, just return in WinMain will call ExitProcess, and that means all threads are should be terminated.

Correct me if it's wrong.