How to Kill a Process in Linux From the Command Line

Are you tired of unresponsive programs, resource-hogging applications, or rogue processes slowing your Linux system?

Look no further! In this comprehensive guide, we’ll talk about various techniques you can use to kill, force kill, and terminate processes in Ubuntu, Fedora, and other Linux distributions.

Whether you’re troubleshooting a stubborn process, ending a runaway job, or simply closing an application from the terminal, we’ve got you covered.

In this post, we will explore the power of the `kill` command, learn how to force-kill processes, and discover how to target specific PIDs, ports, and even users.

But before we kill processes, let’s first refresh our knowledge of what processes are!

What is a Process in Linux?

In Linux, a process is an instance of a running program. Each process has its own memory space, system resources, and a unique Process ID (PID) the kernel assigns. Processes can be applications, system services, or background tasks essential for the operating system’s functionality.

Suggested read: Introduction to Bash For Loops: A Beginner’s Guide 

What is Killing a Process in Linux?

Killing a process in Linux refers to terminating or stopping a running program forcefully. This action is often necessary when a process becomes unresponsive, consumes too many system resources, or needs to be stopped for maintenance or security reasons. Linux provides several methods to kill processes, ranging from graceful termination signals to forceful stops.

When you kill a process, you’re essentially sending a signal to that process, instructing it to terminate. The most common signal used for this purpose is SIGTERM (signal 15), which allows the process to perform cleanup operations before exiting.

In cases where a process doesn’t respond to SIGTERM, users can employ stronger signals such as SIGKILL (signal 9), which forces immediate termination without allowing for cleanup.

Suggested read: How MailHog Can Transform Your Local Email Testing Process 

Reasons to Kill or Terminate a Process in Linux

There are various scenarios where killing a process becomes necessary:

• Unresponsive Applications: When a program freezes or becomes unresponsive, terminating it can free up system resources and allow for a restart.
• Resource Management: Processes consuming excessive CPU or memory can be killed to maintain system stability and performance.
• Security Concerns: Suspicious or potentially malicious processes should be terminated to prevent security breaches.
• System Maintenance: During system updates or reconfigurations, certain processes may need to be stopped.
• Debugging: Developers often need to terminate processes during software testing and debugging.
• Freeing Up Ports: Killing a process can release network ports that are being held, allowing other applications to use them.
• Clearing File Locks: Terminating a process can release file locks, enabling access to previously locked files or directories.
• Stopping Runaway Processes: Accidental infinite loops or other programming errors can create runaway processes that need to be stopped.

Suggested read: What is Docker And How Does it Work 

How to Kill a Process in Linux

There are several ways to kill a process in Linux, but the first step is always to identify the process you want to kill. Once you identify the process, you can choose the following method based on your needs:

How to Kill a Process Using the kill Command With a PID

1. Finding the Process ID (PID): To kill a process, you must first know its Process ID (PID). The ps command, combined with grep, helps you find this. Open your terminal and type:

ps aux | grep process_name

Replace “process_name” with the program name you want to terminate. For example, if you’re looking for a Firefox process, you might type:

ps aux | grep firefox

This command will display a list of processes matching the name. The second column in the output shows the PID.

2. Using the kill command: Once you have the PID, you can use the kill command to terminate the process:

kill PID

Replace “PID” with the actual number you found. For instance:

kill 1234

This sends a SIGTERM signal, asking the process to shut down gracefully.

3. Forceful termination: If the process doesn’t respond to the regular kill command, you can use a stronger signal, SIGKILL (9), which forces immediate termination:

kill -9 PID

Be cautious with SIGKILL as it doesn’t allow the process to clean up, potentially leading to data loss or corruption.

How to Kill Multiple Processes

Sometimes, you need to terminate multiple processes simultaneously. Linux provides efficient ways to do this:

1. Using kill with multiple PIDs: If you know the PIDs of all processes you want to terminate, you can list them after the kill command:

kill PID1 PID2 PID3

For example:

kill 1234 5678 9101

2. Using command substitution: A more dynamic approach is to use command substitution with pgrep. This method kills all processes matching a name:

kill $(pgrep process_name)

For instance, to kill all Firefox processes:

kill $(pgrep firefox)

This command first uses pgrep to find all PIDs associated with Firefox, then passes these PIDs to the kill command.

Suggested read: Everything You Need To Know About wp-config.php File 

How to Kill a Process Using the pkill Command

The pkill command simplifies process termination by allowing you to kill processes based on their names rather than PIDs:

1. Basic usage: To kill a process by name, simply type: pkill process_name
    This will terminate all processes with “process_name” in their names.
2. Case-insensitive matching: If you need clarification on the exact capitalization of the process name, use the -i option. For instance: pkill -i firefox will match “Firefox”, “firefox”, or any other case variation.

How to Kill a Process Using the killall Command

The killall command is similar to pkill but requires an exact match of the process name:

1. Basic usage: To kill all processes with an exact name match: killall process_name
2. Forceful termination: For stubborn processes use the -9 option (equivalent to SIGKILL): killall -9 process_name

Suggested read: Mastering the Echo Command in Linux (with Practical Examples) 

How to Kill Process in Linux by User

Sometimes, you need to terminate all processes owned by a specific user:

1. Listing user processes: First, you can list all processes for a user: ps -u username
    Replace “username” with the actual username.

2. Killing user processes: To kill all processes for a user, use pkill with the -u option:
   pkill -u username. For example: pkill -u john

3. Using killall for user processes: Alternatively, you can use the killall command to kill a particular user’s processes, as shown below.

killall -u username

Suggested read: What are Linux Logs? What Are They & How To Use Them 

How to Kill a Process in Linux by Name

Killing processes by name is often more convenient than using PIDs. There are several ways to do this:

1. Using pkill: The simplest method is by running the following command:
   pkill process_name. Don’t forget to replace process_name with the name of the process you are trying to kill.

2. Partial name matching: Use the -f option to match a substring in the process name for more flexible matching. This is useful for processes with long or complex names. The syntax of this command is as follows:

pkill -f "partial_process_name"

For example, pkill -f "firefox" would match any process with “firefox” anywhere in its command line.

How to Kill a Process in Linux with Bash Script

Creating a bash script for process termination can be helpful for repetitive tasks. Follow the steps below to avoid typing the long and complex commands:

1. Create the script: Use a text editor to create a file named kill_process.sh. For example, you can use the nano editor to create the file using the following command:
   nano kill_process.sh.
2. Add the script content: After creating the file, paste the following content into it:

#!/bin/bash
process_name=$1
pid=$(pgrep -f "$process_name")
if [ -z "$pid" ]; then
    echo "Process not found."
else
    kill $pid
    echo "Process $process_name (PID: $pid) killed."
fi

Once you add the content, you can save it and exit it from the file editor. This script takes a process name as an argument, finds its PID, and terminates it.

Before you can execute the script, you need to make it executable. Change the file permissions by executing the following command to make it executable:

chmod +x kill_process.sh

After changing the file permissions, you can run the script by simply typing its name in the command line, followed by the name of the process you want to kill. For example:

./kill_process.sh firefox

The above command will attempt to kill a process named “firefox” on your computer.

Wrapping Up

In this post, we’ve explored various methods for killing processes in Linux from the command line. From using the kill command with a process ID to tools such as pkill and killall, you should now understand how to terminate unwanted or misbehaving processes on your Linux system.

While a good understanding of the Linux command line is helpful for managing your website, it is not a requirement.

With the help of a hosting platform like RunCloud, you can easily manage your Linux server without getting bogged down in the technical details.

RunCloud provides a user-friendly interface that simplifies server management, allowing you to focus on building and growing your online presence.

Whether you’re a seasoned Linux user or just getting started, RunCloud makes it easy to deploy, monitor, and handle mundane tasks like performing regular backups.

Ready to take your website to the next level? Sign up for RunCloud today and let us handle the Linux management so you can spend more time on what matters most – your business.

FAQs on Killing Linux Processes