Python os.kill Function

Last modified April 11, 2025

This comprehensive guide explores Python's os.kill function, which sends signals to processes. We'll cover signal types, process IDs, and practical process management examples.

Basic Definitions

The os.kill function sends a specified signal to a process identified by its process ID (PID). It's a wrapper around the Unix kill system call.

Key parameters: pid (process ID to signal), sig (signal number to send). Common signals include SIGTERM (15), SIGKILL (9), and SIGHUP (1).

Sending SIGTERM to a Process

SIGTERM (signal 15) is the default termination signal. It allows the process to perform cleanup before exiting. This is the polite way to request termination.

terminate_process.py

import os
import signal
import time
import subprocess

# Start a long-running process
process = subprocess.Popen(["python", "-c", "while True: pass"])

print(f"Process started with PID: {process.pid}")

# Wait a bit then send SIGTERM
time.sleep(2)
os.kill(process.pid, signal.SIGTERM)

# Wait for process to terminate
process.wait()
print(f"Process terminated with return code: {process.returncode}")

This example starts a Python process that runs indefinitely, then sends SIGTERM to request termination. The process can catch and handle SIGTERM.

The subprocess.Popen.wait() ensures we wait for the process to actually terminate after sending the signal.

Forcefully Killing a Process with SIGKILL

SIGKILL (signal 9) immediately terminates a process without cleanup. The process cannot catch or ignore this signal. Use as a last resort.

kill_process.py

import os
import signal
import subprocess
import time

# Start a process that ignores SIGTERM
cmd = '''
import signal, time
signal.signal(signal.SIGTERM, signal.SIG_IGN)
while True: time.sleep(1)
'''
process = subprocess.Popen(["python", "-c", cmd])

print(f"Process started with PID: {process.pid}")

# First try SIGTERM (will be ignored)
os.kill(process.pid, signal.SIGTERM)
time.sleep(1)

# Process still running, use SIGKILL
if process.poll() is None:
    print("SIGTERM failed, sending SIGKILL")
    os.kill(process.pid, signal.SIGKILL)
    process.wait()

print(f"Process terminated with return code: {process.returncode}")

This shows how SIGKILL can terminate a process that ignores SIGTERM. The process.poll() checks if the process is still running after SIGTERM.

SIGKILL should be used sparingly as it doesn't allow for proper cleanup of resources like open files or network connections.

Sending SIGHUP to Reload Configuration

SIGHUP (signal 1) traditionally indicates a terminal disconnect, but is often used to reload configuration. Many daemons reload config on SIGHUP.

reload_config.py

import os
import signal
import subprocess
import time

# Start a process that handles SIGHUP
cmd = '''
import signal, time

def handle_hup(signum, frame):
    print("Received SIGHUP, reloading config")
    
signal.signal(signal.SIGHUP, handle_hup)
while True: time.sleep(1)
'''
process = subprocess.Popen(["python", "-c", cmd], 
                          stdout=subprocess.PIPE,
                          universal_newlines=True)

print(f"Process started with PID: {process.pid}")

# Send SIGHUP to trigger config reload
time.sleep(1)
os.kill(process.pid, signal.SIGHUP)

# Read process output
print(process.stdout.readline())

# Clean up
os.kill(process.pid, signal.SIGTERM)
process.wait()

This demonstrates a process that catches SIGHUP to reload configuration. The subprocess captures stdout so we can see the reload message.

Many server applications like nginx and Apache use SIGHUP for graceful configuration reloading without restarting.

Sending Signals to Process Groups

Negative PIDs send signals to entire process groups. This is useful for terminating all child processes together with their parent.

process_group.py

import os
import signal
import subprocess
import time

# Start a process that creates children
cmd = '''
import os, time, subprocess
print(f"Parent PID: {os.getpid()}")
children = [subprocess.Popen(["sleep", "60"]) for _ in range(3)]
[print(f"Child PID: {c.pid}") for c in children]
time.sleep(60)
'''
process = subprocess.Popen(["python", "-c", cmd], 
                         stdout=subprocess.PIPE,
                         universal_newlines=True)

# Read PIDs from output
parent_pid = int(process.stdout.readline().split(":")[1])
child_pids = [int(process.stdout.readline().split(":")[1]) for _ in range(3)]

print(f"Parent PID: {parent_pid}")
print(f"Child PIDs: {child_pids}")

# Send SIGTERM to entire process group
time.sleep(1)
os.kill(-parent_pid, signal.SIGTERM)

# Verify all processes terminated
for pid in [parent_pid] + child_pids:
    try:
        os.kill(pid, 0)  # Check if process exists
        print(f"Process {pid} still running!")
    except ProcessLookupError:
        print(f"Process {pid} terminated")

This creates a parent process with three child processes. Sending SIGTERM to the negative parent PID terminates the entire process group.

Process groups ensure all related processes can be managed together, which is particularly useful for shell job control and service management.

Checking Process Existence with Signal 0

Signal 0 doesn't actually send a signal but checks if sending is possible. This can verify if a process exists and if you have permission to signal it.

check_process.py

import os
import subprocess
import time

# Start a temporary process
process = subprocess.Popen(["sleep", "10"])
pid = process.pid

print(f"Checking process with PID: {pid}")

# Check if process exists
try:
    os.kill(pid, 0)
    print(f"Process {pid} exists and can be signaled")
except ProcessLookupError:
    print(f"Process {pid} does not exist")
except PermissionError:
    print(f"No permission to signal process {pid}")

# Wait for process to finish and check again
process.wait()
try:
    os.kill(pid, 0)
except ProcessLookupError:
    print(f"Process {pid} no longer exists after completion")

This demonstrates using signal 0 to check process existence. The first check succeeds while the process runs, the second fails after completion.

This technique is useful for process monitoring and health checks without actually interrupting the target process.

Handling Signals in Python

Python processes can catch and handle signals using the signal module. This example shows a Python process that gracefully handles termination.

signal_handler.py

import os
import signal
import sys
import time

def handle_term(signum, frame):
    print(f"Received signal {signum}, cleaning up...")
    # Perform cleanup here
    time.sleep(1)  # Simulate cleanup
    print("Cleanup complete, exiting")
    sys.exit(0)

# Register signal handlers
signal.signal(signal.SIGTERM, handle_term)
signal.signal(signal.SIGHUP, handle_term)

print(f"Running with PID: {os.getpid()}")
print("Send SIGTERM or SIGHUP to trigger handler")

# Main loop
while True:
    time.sleep(1)
    print("Working...")

This script registers handlers for SIGTERM and SIGHUP. When either signal is received, the cleanup function runs before exiting.

Signal handlers allow processes to shutdown gracefully, saving state and releasing resources properly when terminated.

Windows Considerations

On Windows, os.kill has limited functionality compared to Unix:

Only SIGTERM is supported (treated as TerminateProcess)
No process groups (negative PIDs don't work)
No other signal numbers are supported
Works only on processes created by same user

Security Considerations

Permission requirements: Need permission to signal target process
PID reuse: PIDs can be recycled after process termination
Race conditions: Process may terminate between check and signal
Privilege escalation: Some signals can be security sensitive
Windows limitations: Reduced functionality on Windows

Best Practices

Prefer SIGTERM: Allow processes to clean up before exiting
Reserve SIGKILL: Use only when absolutely necessary
Check permissions: Verify you can signal the process first
Handle errors: Process may not exist or you may lack permissions
Consider alternatives: For subprocesses, use Popen methods

Source References

Author

My name is Jan Bodnar, and I am a passionate programmer with extensive programming experience. I have been writing programming articles since 2007. To date, I have authored over 1,400 articles and 8 e-books. I possess more than ten years of experience in teaching programming.

List all Python tutorials.

Ebooks