🕷️ Crawler Inspector

[SuperFastPython](https://superfastpython.com/) [Tutorial Archive](https://superfastpython.com/tutorial-archive.html) # Kill a Process in Python May 22, 2022 [Python Multiprocessing](https://superfastpython.com/tutorial-archive.html) You can kill a child process using the **Process.kill()** or **Process.terminate()** methods. In this tutorial you will discover how to **forcefully terminate or kill a process in Python**. Let's get started. ## Need to Kill a Process A [process](https://en.wikipedia.org/wiki/Process_\(computing\)) is a running instance of a computer program. Every Python program is executed in a Process, which is a new instance of the Python interpreter. This process has the name MainProcess and has one thread used to execute the program instructions called the MainThread. Both processes and threads are created and managed by the underlying operating system. Sometimes we may need to create new child processes in our program in order to execute code concurrently. Python provides the ability to create and manage new processes via the [**multiprocessing.Process** class](https://docs.python.org/3/library/multiprocessing.html#multiprocessing.Process). You can learn more about multiprocessing in the tutorial: - [Multiprocessing in Python: The Complete Guide](https://superfastpython.com/multiprocessing-in-python/) In concurrent programming, we sometimes may need to forcefully kill a child process. This may be for many reasons, such as: - The child process is out of control. - The conditions required by the child process have changed. - The program needs to be stopped immediately. **How can we forcefully terminate or kill a child process in Python?** ## How to Kill a Process Killing a process is drastic. If possible, it is better to safely stop a child process. This can be achieved in many ways. A common and reliable approach is to use a shared **multiprocessing.Event** object. The child process can check the status of the event frequently, and if set, it can clean-up resources and choose to stop. You can learn more about safely stopping a child process in the tutorial: - [How to Safely Stop a Process in Python](https://superfastpython.com/safely-stop-a-process-in-python/) Nevertheless, a process can be forcefully stopped immediately. The downside is that the process will not have an opportunity to clean-up, making it possibly unsafe. Specifically: - The finally clauses in try-except-finally or try-finally patterns will not be executed. - The exit handlers will not be executed. This means that open resources like files and sockets will not be closed in a safe and controlled manner. It also means that any application state will not be updated. Nevertheless, sometimes we may need to immediately kill a child process. There are two main approaches to kill a process, they are: - Terminate a process via **Process.terminate()**. - Kill a process via **Process.kill()**. Let's take a closer look at each in turn. ### Call terminate() on Process A process can be killed by calling the [**Process.terminate()** function](https://docs.python.org/3/library/multiprocessing.html#multiprocessing.Process.terminate). The call will only terminate the target process, not child processes. The method is called on the **multiprocessing.Process** instance for the process that you wish to terminate. You may have this instance from creating the process or it may be acquired via module methods such as the [**multiprocessing.active\_children()** function](https://docs.python.org/3/library/multiprocessing.html#multiprocessing.active_children). For example: ``` ... # terminate the process process.terminate() ``` The method takes no arguments and does not block. The function will terminate the process using the [SIGTERM](https://en.wikipedia.org/wiki/Signal_\(IPC\)#SIGTERM) (signal terminate) signal on most platforms, or the equivalent on windows. > The SIGTERM signal is sent to a process to request its termination. Unlike the SIGKILL signal, it can be caught and interpreted or ignored by the process. This allows the process to perform nice termination releasing resources and saving state if appropriate. SIGINT is nearly identical to SIGTERM. > > \-- [SIGTERM, Wikipedia](https://en.wikipedia.org/wiki/Signal_\(IPC\)#SIGTERM). ### Call kill() on Process A process can be killed by calling the [**Process.kill()** function](https://docs.python.org/3/library/multiprocessing.html#multiprocessing.Process.kill). The call will only terminate the target process, not child processes. The method is called on the multiprocessing.Process instance for the process that you wish to terminate. You may have this instance from creating the process or it may be acquired via module methods such as the [**multiprocessing.active\_children()** function](https://docs.python.org/3/library/multiprocessing.html#multiprocessing.active_children). For example: ``` ... # kill the process process.kill() ``` The method takes no arguments and does not block. The function will terminate the process using the [SIGKILL](https://en.wikipedia.org/wiki/Signal_\(IPC\)#SIGKILL) (signal kill) signal on most platforms, or the equivalent on windows. This signal cannot be ignored and cannot be handled. > The SIGKILL signal is sent to a process to cause it to terminate immediately (kill). In contrast to SIGTERM and SIGINT, this signal cannot be caught or ignored, and the receiving process cannot perform any clean-up upon receiving this signal. > > \-- [SIGKILL, Wikipedia](https://en.wikipedia.org/wiki/Signal_\(IPC\)#SIGKILL). Now that we know how to kill a process let's look at some worked examples. ## Example of Terminating a Process We can explore how to terminate a process. In this example we will create a child process that will run a task in a loop forever. The parent process will wait a while then choose to forcefully terminate the process. First, let's define a task function that we can execute in a child process. The function will use a while-loop and will loop forever. Each iteration, it will block for one second with a call to **time.sleep()** then report a message. The **task()** function below implements this. ``` # custom task function def task(): # execute a task in a loop while True: # block for a moment sleep(1) # report a message print('Worker process running...', flush=True) ``` Next, in the parent process we can create a new **multiprocessing.Process** instance to run our **task()** function in a new child process. This can be achieved using the "**target**" keyword of the **multiprocessing.Process** class constructor. ``` ... # create a process process = Process(target=task) ``` Once created, we can start the process. ``` ... # run the process process.start() ``` The parent process can then block for five seconds with a call to **time.sleep()**. ``` ... # wait for a moment sleep(5) ``` The parent process will then wake up and forcefully terminate the child process. ``` ... # terminate the process process.terminate() ``` The main process will then carry on, in this case reporting a message. ``` ... # continue on... print('Parent is continuing on...') ``` Tying this together, the complete example is listed below. ``` # SuperFastPython.com # example of terminating a process from time import sleep from multiprocessing import Process # custom task function def task(): # execute a task in a loop while True: # block for a moment sleep(1) # report a message print('Worker process running...', flush=True) # entry point if __name__ == '__main__': # create a process process = Process(target=task) # run the process process.start() # wait for a moment sleep(5) # terminate the process process.terminate() # continue on... print('Parent is continuing on...') ``` Running the example first creates and starts a new child process to run our target function. The child process is started and the parent process blocks. The child process attempts to run forever, reporting a message and sleeping for a second each iteration. The parent process wakes up then forcefully terminates the child process. The child process is stopped immediately. The parent process then carries on and then decides to stop. ``` Worker process running... Worker process running... Worker process running... Worker process running... Parent is continuing on... ``` Next, let's look at killing a process. ## Example of Killing a Process We can explore how to kill a process. In this example we will create a child process that will run a task in a loop forever, as in the previous section. The parent process will wait a while then choose to kill the child process. First, let's define a task function that we can execute in a child process. The function will use a while-loop and will loop forever. Each iteration, it will block for one second with a call to **time.sleep()** then report a message. The **task()** function below implements this. ``` # custom task function def task(): # execute a task in a loop while True: # block for a moment sleep(1) # report a message print('Worker process running...', flush=True) ``` Next, in the parent process we can create a new **multiprocessing.Process** instance to run our **task()** function in a new child process. This can be achieved using the "**target**" keyword of the **multiprocessing.Process** class constructor. ``` ... # create a process process = Process(target=task) ``` Once created, we can start the process. ``` ... # run the process process.start() ``` The parent process can then block for five seconds with a call to **time.sleep()**. ``` ... # wait for a moment sleep(5) ``` The parent process will then wake up and kill the child process. ``` ... # kill the process process.kill() ``` The main process will then carry on, in this case reporting a message. ``` ... # continue on... print('Parent is continuing on...') ``` Tying this together, the complete example is listed below. ``` # SuperFastPython.com # example of killing a process from time import sleep from multiprocessing import Process # custom task function def task(): # execute a task in a loop while True: # block for a moment sleep(1) # report a message print('Worker process running...', flush=True) # entry point if __name__ == '__main__': # create a process process = Process(target=task) # run the process process.start() # wait for a moment sleep(5) # kill the process process.kill() # continue on... print('Parent is continuing on...') ``` Running the example first creates and starts a new child process to run our target function. The child process is started and the parent process blocks. The child process attempts to run forever, reporting a message and sleeping for a second each iteration. The parent process wakes up then kills the child process. The child process is stopped immediately. The parent process then carries on and then decides to stop. ``` Worker process running... Worker process running... Worker process running... Worker process running... Parent is continuing on... ``` ## Common Questions This section lists common questions about killing a process. **Do you have a question?** Let me know in the comments below and I may add it to this section. ### When to Use terminate() vs kill()? Generally, a SIGTERM sent via **terminate()** is less forceful than SIGKILL sent via **kill()**. This is because a SIGTERM can be handled with a signal handler, whereas a SIGKILL cannot. Nevertheless, for most purposes, the two approaches are equivalent. ### Can the SIGTERM Triggered via Process.terminate() Be Handled? Yes. You can register a function to handle the signal via the [**signal.signal()** function](https://docs.python.org/3/library/signal.html#signal.signal). The example below demonstrates how to register a handler for SIGTERM in the child process, allowing it to clean-up before exiting. ``` # SuperFastPython.com # example of terminating a child process, and handling the signal from time import sleep from multiprocessing import Process from signal import signal from signal import SIGTERM import sys # handle signal def handler(sig, frame): print('Child process cleaning up...') sleep(2) # kill the process sys.exit(0) # custom task function def task(): # handle sigterm signal(SIGTERM, handler) # execute a task in a loop while True: # block for a moment sleep(1) # report a message print('Worker process running...', flush=True) # entry point if __name__ == '__main__': # create a process process = Process(target=task) # run the process process.start() # wait for a moment sleep(5) # terminate the process process.terminate() # continue on... print('Parent is continuing on...') ``` ### Can the SIGKILL Triggered via Process.kill() Be Handled? No. ### What Happens to Child Processes? A process with child processes may be killed. In this case, the target process is killed and the child processes are left untouched. As they no longer have a parent process, they are referred to as [orphan processes](https://en.wikipedia.org/wiki/Orphan_process). ## Takeaways You now know how to forcefully kill a process in Python. If you enjoyed this tutorial, you will love my book: **[Python Multiprocessing Jump-Start](https://amzn.to/41Ly8Vu)**. It covers everything you need to master the topic with hands-on examples and clear explanations. © 2026 [SuperFastPython](https://superfastpython.com/)

You can kill a child process using the **Process.kill()** or **Process.terminate()** methods. In this tutorial you will discover how to **forcefully terminate or kill a process in Python**. Let's get started. ## Need to Kill a Process A [process](https://en.wikipedia.org/wiki/Process_\(computing\)) is a running instance of a computer program. Every Python program is executed in a Process, which is a new instance of the Python interpreter. This process has the name MainProcess and has one thread used to execute the program instructions called the MainThread. Both processes and threads are created and managed by the underlying operating system. Sometimes we may need to create new child processes in our program in order to execute code concurrently. Python provides the ability to create and manage new processes via the [**multiprocessing.Process** class](https://docs.python.org/3/library/multiprocessing.html#multiprocessing.Process). You can learn more about multiprocessing in the tutorial: - [Multiprocessing in Python: The Complete Guide](https://superfastpython.com/multiprocessing-in-python/) In concurrent programming, we sometimes may need to forcefully kill a child process. This may be for many reasons, such as: - The child process is out of control. - The conditions required by the child process have changed. - The program needs to be stopped immediately. **How can we forcefully terminate or kill a child process in Python?** ## How to Kill a Process Killing a process is drastic. If possible, it is better to safely stop a child process. This can be achieved in many ways. A common and reliable approach is to use a shared **multiprocessing.Event** object. The child process can check the status of the event frequently, and if set, it can clean-up resources and choose to stop. You can learn more about safely stopping a child process in the tutorial: - [How to Safely Stop a Process in Python](https://superfastpython.com/safely-stop-a-process-in-python/) Nevertheless, a process can be forcefully stopped immediately. The downside is that the process will not have an opportunity to clean-up, making it possibly unsafe. Specifically: - The finally clauses in try-except-finally or try-finally patterns will not be executed. - The exit handlers will not be executed. This means that open resources like files and sockets will not be closed in a safe and controlled manner. It also means that any application state will not be updated. Nevertheless, sometimes we may need to immediately kill a child process. There are two main approaches to kill a process, they are: - Terminate a process via **Process.terminate()**. - Kill a process via **Process.kill()**. Let's take a closer look at each in turn. ### Call terminate() on Process A process can be killed by calling the [**Process.terminate()** function](https://docs.python.org/3/library/multiprocessing.html#multiprocessing.Process.terminate). The call will only terminate the target process, not child processes. The method is called on the **multiprocessing.Process** instance for the process that you wish to terminate. You may have this instance from creating the process or it may be acquired via module methods such as the [**multiprocessing.active\_children()** function](https://docs.python.org/3/library/multiprocessing.html#multiprocessing.active_children). For example: ``` ... # terminate the process process.terminate() ``` The method takes no arguments and does not block. The function will terminate the process using the [SIGTERM](https://en.wikipedia.org/wiki/Signal_\(IPC\)#SIGTERM) (signal terminate) signal on most platforms, or the equivalent on windows. > The SIGTERM signal is sent to a process to request its termination. Unlike the SIGKILL signal, it can be caught and interpreted or ignored by the process. This allows the process to perform nice termination releasing resources and saving state if appropriate. SIGINT is nearly identical to SIGTERM. > > \-- [SIGTERM, Wikipedia](https://en.wikipedia.org/wiki/Signal_\(IPC\)#SIGTERM). ### Call kill() on Process A process can be killed by calling the [**Process.kill()** function](https://docs.python.org/3/library/multiprocessing.html#multiprocessing.Process.kill). The call will only terminate the target process, not child processes. The method is called on the multiprocessing.Process instance for the process that you wish to terminate. You may have this instance from creating the process or it may be acquired via module methods such as the [**multiprocessing.active\_children()** function](https://docs.python.org/3/library/multiprocessing.html#multiprocessing.active_children). For example: ``` ... # kill the process process.kill() ``` The method takes no arguments and does not block. The function will terminate the process using the [SIGKILL](https://en.wikipedia.org/wiki/Signal_\(IPC\)#SIGKILL) (signal kill) signal on most platforms, or the equivalent on windows. This signal cannot be ignored and cannot be handled. > The SIGKILL signal is sent to a process to cause it to terminate immediately (kill). In contrast to SIGTERM and SIGINT, this signal cannot be caught or ignored, and the receiving process cannot perform any clean-up upon receiving this signal. > > \-- [SIGKILL, Wikipedia](https://en.wikipedia.org/wiki/Signal_\(IPC\)#SIGKILL). Now that we know how to kill a process let's look at some worked examples. ## Example of Terminating a Process We can explore how to terminate a process. In this example we will create a child process that will run a task in a loop forever. The parent process will wait a while then choose to forcefully terminate the process. First, let's define a task function that we can execute in a child process. The function will use a while-loop and will loop forever. Each iteration, it will block for one second with a call to **time.sleep()** then report a message. The **task()** function below implements this. ``` # custom task function def task(): # execute a task in a loop while True: # block for a moment sleep(1) # report a message print('Worker process running...', flush=True) ``` Next, in the parent process we can create a new **multiprocessing.Process** instance to run our **task()** function in a new child process. This can be achieved using the "**target**" keyword of the **multiprocessing.Process** class constructor. ``` ... # create a process process = Process(target=task) ``` Once created, we can start the process. ``` ... # run the process process.start() ``` The parent process can then block for five seconds with a call to **time.sleep()**. ``` ... # wait for a moment sleep(5) ``` The parent process will then wake up and forcefully terminate the child process. ``` ... # terminate the process process.terminate() ``` The main process will then carry on, in this case reporting a message. ``` ... # continue on... print('Parent is continuing on...') ``` Tying this together, the complete example is listed below. ``` # SuperFastPython.com # example of terminating a process from time import sleep from multiprocessing import Process # custom task function def task(): # execute a task in a loop while True: # block for a moment sleep(1) # report a message print('Worker process running...', flush=True) # entry point if __name__ == '__main__': # create a process process = Process(target=task) # run the process process.start() # wait for a moment sleep(5) # terminate the process process.terminate() # continue on... print('Parent is continuing on...') ``` Running the example first creates and starts a new child process to run our target function. The child process is started and the parent process blocks. The child process attempts to run forever, reporting a message and sleeping for a second each iteration. The parent process wakes up then forcefully terminates the child process. The child process is stopped immediately. The parent process then carries on and then decides to stop. ``` Worker process running... Worker process running... Worker process running... Worker process running... Parent is continuing on... ``` Next, let's look at killing a process. ## Example of Killing a Process We can explore how to kill a process. In this example we will create a child process that will run a task in a loop forever, as in the previous section. The parent process will wait a while then choose to kill the child process. First, let's define a task function that we can execute in a child process. The function will use a while-loop and will loop forever. Each iteration, it will block for one second with a call to **time.sleep()** then report a message. The **task()** function below implements this. ``` # custom task function def task(): # execute a task in a loop while True: # block for a moment sleep(1) # report a message print('Worker process running...', flush=True) ``` Next, in the parent process we can create a new **multiprocessing.Process** instance to run our **task()** function in a new child process. This can be achieved using the "**target**" keyword of the **multiprocessing.Process** class constructor. ``` ... # create a process process = Process(target=task) ``` Once created, we can start the process. ``` ... # run the process process.start() ``` The parent process can then block for five seconds with a call to **time.sleep()**. ``` ... # wait for a moment sleep(5) ``` The parent process will then wake up and kill the child process. ``` ... # kill the process process.kill() ``` The main process will then carry on, in this case reporting a message. ``` ... # continue on... print('Parent is continuing on...') ``` Tying this together, the complete example is listed below. ``` # SuperFastPython.com # example of killing a process from time import sleep from multiprocessing import Process # custom task function def task(): # execute a task in a loop while True: # block for a moment sleep(1) # report a message print('Worker process running...', flush=True) # entry point if __name__ == '__main__': # create a process process = Process(target=task) # run the process process.start() # wait for a moment sleep(5) # kill the process process.kill() # continue on... print('Parent is continuing on...') ``` Running the example first creates and starts a new child process to run our target function. The child process is started and the parent process blocks. The child process attempts to run forever, reporting a message and sleeping for a second each iteration. The parent process wakes up then kills the child process. The child process is stopped immediately. The parent process then carries on and then decides to stop. ``` Worker process running... Worker process running... Worker process running... Worker process running... Parent is continuing on... ``` ## Common Questions This section lists common questions about killing a process. **Do you have a question?** Let me know in the comments below and I may add it to this section. ### When to Use terminate() vs kill()? Generally, a SIGTERM sent via **terminate()** is less forceful than SIGKILL sent via **kill()**. This is because a SIGTERM can be handled with a signal handler, whereas a SIGKILL cannot. Nevertheless, for most purposes, the two approaches are equivalent. ### Can the SIGTERM Triggered via Process.terminate() Be Handled? Yes. You can register a function to handle the signal via the [**signal.signal()** function](https://docs.python.org/3/library/signal.html#signal.signal). The example below demonstrates how to register a handler for SIGTERM in the child process, allowing it to clean-up before exiting. ``` # SuperFastPython.com # example of terminating a child process, and handling the signal from time import sleep from multiprocessing import Process from signal import signal from signal import SIGTERM import sys # handle signal def handler(sig, frame): print('Child process cleaning up...') sleep(2) # kill the process sys.exit(0) # custom task function def task(): # handle sigterm signal(SIGTERM, handler) # execute a task in a loop while True: # block for a moment sleep(1) # report a message print('Worker process running...', flush=True) # entry point if __name__ == '__main__': # create a process process = Process(target=task) # run the process process.start() # wait for a moment sleep(5) # terminate the process process.terminate() # continue on... print('Parent is continuing on...') ``` ### Can the SIGKILL Triggered via Process.kill() Be Handled? No. ### What Happens to Child Processes? A process with child processes may be killed. In this case, the target process is killed and the child processes are left untouched. As they no longer have a parent process, they are referred to as [orphan processes](https://en.wikipedia.org/wiki/Orphan_process). ## Takeaways You now know how to forcefully kill a process in Python. If you enjoyed this tutorial, you will love my book: **[Python Multiprocessing Jump-Start](https://amzn.to/41Ly8Vu)**. It covers everything you need to master the topic with hands-on examples and clear explanations.