How To Kill A Process In Linux : Process ID Identification Steps

by

Terminating a process in Linux begins with finding its PID through the ps command. Learning how to kill a process in linux is a core skill for any system administrator or developer. It helps you free up system resources and stop misbehaving applications.

Every process in Linux gets a unique Process ID (PID). You need this number to send termination signals. The most common way to list processes is with ps aux. This shows all running processes with their PID, CPU usage, and memory footprint.

Sometimes a program freezes or consumes too much memory. In those cases, knowing how to kill it quickly saves your system from crashing. Let’s walk through the methods step by step.

How To Kill A Process In Linux

The main command for killing processes is kill. It sends signals to processes based on their PID. The default signal is SIGTERM (signal 15), which asks the process to shut down gracefully.

If a process ignores SIGTERM, you can use SIGKILL (signal 9). This forces the process to stop immediately. It does not give the process time to save data or clean up resources.

You can also use killall and pkill to target processes by name. These tools are very handy when you don’t have the PID memorized.

Finding The Process ID (PID)

Before you can kill anything, you must locate the PID. Use the ps command with different options.

  • ps aux – Shows all processes with detailed info
  • ps -ef – Another standard format for listing processes
  • pgrep firefox – Returns only the PID for Firefox
  • pidof firefox – Similar to pgrep, gives PID numbers

For example, to find a stalled Firefox process, run ps aux | grep firefox. The output will show the PID in the second column. Write that number down.

Another quick method is using top or htop. These interactive tools show real-time process data. Press ‘k’ in htop to kill a selected process directly.

Using The Kill Command

The kill command syntax is simple: kill [signal] PID. The signal can be a number or a name.

  1. Open a terminal window.
  2. Type kill 1234 (replace 1234 with the actual PID).
  3. Press Enter. The process should terminate.

If the process refuses to die, use kill -9 1234 or kill -SIGKILL 1234. This sends the unstoppable kill signal.

Common signals include:

  • SIGTERM (15) – Graceful termination
  • SIGKILL (9) – Forceful termination
  • SIGHUP (1) – Hang up, often reloads config
  • SIGSTOP (19) – Pauses the process
  • SIGCONT (18) – Resumes a paused process

Always try SIGTERM first. It gives the process a chance to close files and release memory. Use SIGKILL only as a last resort.

Killing Processes By Name With Killall

The killall command kills all processes with a specific name. It is very powerful and dangerous if used carelessly.

Example: killall firefox will terminate every Firefox process running on your system. Use the -i flag for interactive mode, which asks for confirmation before each kill.

To kill processes owned by a specific user, add the -u option: killall -u username firefox. This targets only that user’s Firefox instances.

Be careful with killall. If you type killall python, it stops all Python scripts. That could break important services.

Using Pkill For Flexible Matching

pkill works like killall but supports pattern matching. You can use partial names or regular expressions.

For example, pkill fire kills any process with “fire” in its name. This includes Firefox, firewalld, and firejail.

To be more precise, use the -x flag for exact match: pkill -x firefox. This kills only processes named exactly “firefox”.

You can also kill processes by user: pkill -u john firefox. This kills Firefox processes owned by user john.

Killing Processes With Xkill

If you prefer a graphical method, xkill is perfect. It turns your cursor into a crosshair. Click on any window to kill its process.

To use xkill, open a terminal and type xkill. Your cursor changes. Click on the frozen application window. The process terminates instantly.

This method is great for desktop users. It works with any X11-based window manager. No need to remember PIDs or process names.

Note: xkill sends SIGKILL by default. It does not give the application a chance to save data. Use it only for unresponsive programs.

Killing Zombie Processes

Zombie processes are dead processes that still appear in the process table. They usually have a status of “Z” in ps output.

Zombies cannot be killed with normal signals. They are already dead. The problem is that their parent process has not read their exit status.

To clean zombies, you must kill or restart the parent process. Use ps -eo pid,ppid,stat,cmd | grep Z to find zombie PIDs and their parents.

If the parent is PID 1 (init or systemd), you may need to reboot the system. Zombies attached to init are rare but problematic.

Prevent zombies by writing proper signal handling in your programs. Always call wait() or waitpid() in the parent process.

Killing Processes With Specific Ports

Sometimes you need to kill a process listening on a specific port. This is common when starting a server and getting “address already in use” errors.

Use lsof -i :8080 to find the PID using port 8080. The output shows the process name and PID.

Alternatively, use fuser 8080/tcp. This returns the PID directly. Then kill it with kill -9 PID.

Another tool is netstat -tulpn | grep :8080. This shows the PID and program name. Note that you may need root privileges for some PIDs.

Killing Processes By User

If a user has many runaway processes, you can kill them all at once. Use pkill -u username to kill every process owned by that user.

This is useful when a user logs out but leaves processes running. It can free up significant resources.

Be careful: this kills all processes, including shell sessions. The user will be forcibly logged out.

To kill only specific processes for a user, combine with the process name: pkill -u username firefox.

Using Systemd To Kill Services

Modern Linux systems use systemd to manage services. To kill a systemd service, use systemctl stop servicename.

If the service does not stop, use systemctl kill servicename. This sends SIGTERM to all processes in the service’s cgroup.

For a forceful kill, add the --signal=SIGKILL flag: systemctl kill --signal=SIGKILL servicename.

Systemd also provides systemctl --user for user services. This works the same way but for per-user processes.

Automating Process Killing With Scripts

You can write shell scripts to kill processes automatically. This is useful for monitoring and cleanup tasks.

Example script to kill Firefox if it uses too much memory:

#!/bin/bash
PID=$(pgrep firefox)
MEM=$(ps -p $PID -o %mem --no-headers)
if (( $(echo "$MEM > 50.0" | bc -l) )); then
  kill $PID
fi

Save this as a script and run it with cron. It checks Firefox memory usage every minute and kills it if above 50%.

Another common automation is killing stale SSH sessions. Use pkill -u username sshd to terminate all SSH daemon processes for a user.

Safety Tips When Killing Processes

Killing the wrong process can crash your system. Always double-check the PID before running kill.

Use ps -p PID -o comm to verify the process name. This shows the command that started the process.

Never kill init (PID 1). This is the parent of all processes. Killing it will crash the system.

Also avoid killing kernel threads. These have names in brackets like [kworker] or [kswapd]. They are essential for system operation.

Use the -l flag with kill to list all available signals. This helps you choose the right signal for the situation.

Common Mistakes And How To Avoid Them

One common mistake is forgetting to use sudo. Some processes are owned by root and require root privileges to kill.

If you get “Operation not permitted”, run the command with sudo. For example, sudo kill -9 1234.

Another mistake is killing the wrong PID. Always verify with ps before sending the signal.

Using killall without the -i flag can kill multiple processes unintentionally. Add -i to confirm each kill.

Finally, relying too much on SIGKILL can cause data loss. Always try SIGTERM first. It gives processes time to save state.

Advanced Techniques: Signal Handling And Process Groups

Process groups allow you to kill multiple related processes at once. Use kill -SIGTERM -PGID to kill an entire group.

To find the process group ID, use ps -o pid,pgid,comm. The PGID column shows the group ID.

You can also use kill -SIGTERM 0 to send a signal to all processes in your current process group. This is useful in scripts.

Signal handling is important for developers. You can trap signals in your programs to perform cleanup before exiting.

For example, a Python script can catch SIGTERM and close files gracefully:

import signal, sys
def handler(signum, frame):
  print("Cleaning up...")
  sys.exit(0)
signal.signal(signal.SIGTERM, handler)

Killing Processes In Different Environments

In Docker containers, killing processes works the same way. Use docker exec to run kill commands inside the container.

For example: docker exec container_name kill 1234. Or use docker kill container_name to stop the entire container.

In Kubernetes, you use kubectl exec pod_name -- kill 1234. Kubernetes also provides kubectl delete pod to terminate pods.

On headless servers without a GUI, the command-line methods are essential. Practice them until they become second nature.

Even in cloud environments like AWS or GCP, the same Linux commands work. SSH into your instance and use kill as usual.

Frequently Asked Questions

What Is The Difference Between Kill And Killall?

kill requires a PID and sends a signal to one process. killall uses a process name and kills all matching processes. Use kill for precision, killall for bulk operations.

Can I Kill A Process Without Knowing Its PID?

Yes, use pkill or killall with the process name. For graphical systems, use xkill and click on the window. These methods do not require the PID.

What Signal Should I Use To Kill A Process?

Start with SIGTERM (15). If the process does not respond, use SIGKILL (9). SIGTERM allows graceful shutdown, while SIGKILL forces immediate termination.

How Do I Kill A Process That Is Stuck?

First try kill -15 PID. If that fails, use kill -9 PID. For zombie processes, kill the parent process. For graphical apps, use xkill.

Is It Safe To Kill System Processes?

Generally no. Killing system processes like init, kernel threads, or critical services can crash your system. Only kill processes you understand and have permission to terminate.

Conclusion

Mastering how to kill a process in linux gives you control over your system’s resources. Start with ps to find the PID, then use kill with the appropriate signal. For convenience, use pkill or killall when you know the process name.

Always try SIGTERM before SIGKILL. This prevents data loss and gives processes time to clean up. Use xkill for desktop applications that freeze.

Practice these commands in a safe environment. Create a test script and kill it. Experiment with different signals. The more you practice, the more confident you will become.

Remember to verify the PID before killing. A moment of checking can save you from a system crash. With these tools and techniques, you can handle any unruly process on your Linux system.