Terminating a Process
A process executes until one of the following events occurs:
- Any thread of the process calls the ExitProcess function. This terminates all threads of the process.
- The primary thread of the process returns. The primary thread can avoid
terminating other threads by explicitly calling ExitThread before it returns. One of the remaining threads can still call ExitProcess to ensure that all threads are terminated.
- The last thread of the process terminates.
- Any thread calls the TerminateProcess function with a handle to the process. This terminates all threads of the
process, without allowing them to clean up or save data.
- For console processes, the default handler function calls ExitProcess when the console receives a CTRL+C or CTRL+BREAK signal. All console processes attached to the console receive these signals.
Detached processes and GUI processes are not affected by CTRL+C or CTRL+BREAK signals. For more information, see SetConsoleCtrlHandler.
- The user shuts down the system or logs off. Use the SetProcessShutdownParameters function to specify shutdown parameters, such as when a process should
terminate relative to the other processes in the system. The GetProcessShutdownParameters function retrieves the current shutdown priority of the process and other
When a process is terminated, all threads of the process are terminated
immediately with no chance to run additional code. This means that the process does
not execute code in termination handler blocks. For more information, see Structured Exception Handling
function returns the termination status of a process. While a process is
executing, its termination status is STILL_ACTIVE. When a process terminates, its
termination status changes from STILL_ACTIVE to the exit code of the process.
The exit code is either the value specified in the call to ExitProcess
, or the value returned by the main or WinMain
function of the process. If a process is terminated due to a fatal exception,
the exit code is the value of the exception that caused the termination. In
addition, this value is used as the exit code for all the threads that were
executing when the exception occurred.
When a process terminates, the state of the process object becomes signaled,
releasing any threads that had been waiting for the process to terminate. For
more about synchronization, see Synchronizing Execution of Multiple Threads
Open handles to files or other resources are closed automatically when a
process terminates. However, the objects themselves exist until all open handles to
them are closed. This means that an object remains valid after a process
closes, if another process has a handle to it.
If a process is terminated by ExitProcess
, the system calls the entry-point function of each attached DLL with a value
indicating that the process is detaching from the DLL. DLLs are not notified
when a process is terminated by TerminateProcess
. For more information about DLLs, see Dynamic-Link Libraries
function should be used only in extreme circumstances, since it does not
allow threads to clean up or save data and does not notify attached DLLs. If you
need to have one process terminate another process, the following steps provide a
- Have both processes call the RegisterWindowMessage function to create a private message.
- One process can terminate the other process by broadcasting the private
message using the BroadcastSystemMessage function as follows:
BSF_IGNORECURRENTTASK, // do not send message to this process
BSM_APPLICATIONS, // broadcast only to applications
// message registered in previous step
wParam, // message-specific value
lParam ); // message-specific value
- The process receiving the private message calls ExitProcess to terminate its execution.
When the system is terminating a process, it does not terminate any child
processes that the process has created.
- Software for developers
Software for Android Developers
- More information resources
Unix Manual Pages
- Databases for Amazon shops developers
Amazon Categories Database
Browse Nodes Database