Introduction
In this lab, you will learn essential Linux process management skills, focusing on how to identify and terminate processes. Process management is a fundamental skill for any Linux user or administrator, as it allows you to manage system resources effectively.
You will learn how to use the ps command to identify running processes and the kill command to terminate them when necessary. These tools are essential for maintaining system performance and dealing with unresponsive applications.
By the end of this lab, you will be able to identify processes, understand their attributes, and terminate them using various methods. These skills are valuable for troubleshooting and managing Linux systems efficiently.
Identifying Processes
In Linux, every running program or application is considered a process. Each process has a unique identifier called a Process ID (PID). Before you can terminate a process, you need to identify it using its PID.
Let's start by learning how to view running processes using the ps command. This command displays information about active processes in your system.
First, open a terminal in the LabEx VM environment and run the following command:
ps
You will see a basic list of processes that are running in your current terminal session. The output should look similar to this:
PID TTY TIME CMD
2104 pts/0 00:00:00 zsh
2116 pts/0 00:00:00 ps
This output shows:
PID: The Process ID numberTTY: The terminal type the process is running onTIME: The amount of CPU time the process has usedCMD: The command that started the process
To see a more comprehensive list of all processes running on the system, use the following command with additional options:
ps -aux
The options mean:
-a: Show processes from all users-u: Display detailed user-oriented format-x: Include processes without a controlling terminal
The output will be much longer and more detailed, showing all processes running on the system:
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
root 1 0.0 0.1 167936 11876 ? Ss 10:30 0:01 /sbin/init
root 2 0.0 0.0 0 0 ? S 10:30 0:00 [kthreadd]
...
labex 2104 0.0 0.1 11108 5456 pts/0 Ss 10:35 0:00 zsh
labex 2130 0.0 0.0 9828 3384 pts/0 R+ 10:36 0:00 ps -aux
Now, let's create a simple background process that we can use for practice:
sleep 300 &
sleep_pid=$!
This command starts a process that will "sleep" (do nothing) for 300 seconds (5 minutes). The & symbol runs it in the background, and $! captures the PID of the most recently started background process.
Let's verify the process is running:
echo "The sleep process ID is: $sleep_pid"
ps | grep sleep
You should see output similar to:
The sleep process ID is: 2135
2135 pts/0 00:00:00 sleep
Now you know how to identify processes and find their PIDs. In the next step, we'll learn how to terminate this process.
Terminating Processes with 'kill'
Now that you've identified a process and its PID, you can learn how to terminate it using the kill command. The kill command sends a signal to a process, instructing it to terminate.
The basic syntax for the kill command is:
kill [options] <PID>
Let's terminate the sleep process we created in the previous step. We stored its PID in the $sleep_pid variable. Use the following command to terminate it:
kill $sleep_pid
If you've forgotten the PID, you can find it again using:
ps | grep sleep
After executing the kill command, verify that the process has been terminated:
ps | grep sleep
If the process was successfully terminated, you should see no output or only the grep process itself in the output. This means the sleep process is no longer running.
If you want to be thorough, you can use the ps command again to list all processes:
ps -aux | grep sleep
This might show something like:
labex 2156 0.0 0.0 7236 720 pts/0 S+ 10:40 0:00 grep --color=auto sleep
The only process shown is the grep command itself, which indicates the sleep process has been terminated.
By default, the kill command sends a TERM (terminate) signal to the process, which allows the process to exit gracefully after performing any cleanup operations. In most cases, this is sufficient to terminate a process.
You've now successfully identified and terminated a process using the kill command, which is a fundamental skill for managing processes in Linux.
Understanding Kill Signals
In Linux, the kill command can send various types of signals to processes, not just termination signals. Understanding these signals gives you more control over how processes are terminated.
First, let's see all available signals by running:
kill -l
This will list all the signals that the kill command can send. The output looks like:
1) SIGHUP 2) SIGINT 3) SIGQUIT 4) SIGILL 5) SIGTRAP
6) SIGABRT 7) SIGBUS 8) SIGFPE 9) SIGKILL 10) SIGUSR1
11) SIGSEGV 12) SIGUSR2 13) SIGPIPE 14) SIGALRM 15) SIGTERM
...
The most commonly used signals are:
SIGTERM(15): Default signal sent by thekillcommand. Asks the process to terminate gracefully.SIGKILL(9): Forces the process to terminate immediately. Use when a process doesn't respond to SIGTERM.SIGHUP(1): Traditionally used to reset or reload configuration files.SIGINT(2): Sent when you press Ctrl+C in the terminal.
Let's create another sleep process to practice with:
sleep 300 &
sleep_pid=$!
echo "The new sleep process ID is: $sleep_pid"
Now, let's send a specific signal to the process using the signal number:
kill -15 $sleep_pid
This is equivalent to the default kill command as it sends SIGTERM (signal 15).
Verify that the process has been terminated:
ps | grep sleep
Let's create one more sleep process to demonstrate the SIGKILL signal:
sleep 300 &
sleep_pid=$!
echo "The third sleep process ID is: $sleep_pid"
Now, let's use the SIGKILL signal to forcefully terminate the process:
kill -9 $sleep_pid
Verify that the process has been terminated:
ps | grep sleep
The SIGKILL signal (9) is a "last resort" option because:
- It does not allow the process to clean up after itself
- It might leave resources in an inconsistent state
- It might cause data loss if the process was writing data
Always try SIGTERM first, and only use SIGKILL if the process is unresponsive to SIGTERM.
Advanced Process Management
Linux provides additional commands for managing processes beyond the basic ps and kill commands. These tools provide more flexibility and convenience for identifying and terminating processes.
The pgrep Command
The pgrep command allows you to find processes by name rather than having to visually scan the output of ps:
pgrep sleep
This command will find all processes with "sleep" in their name and output their PIDs.
The pkill Command
The pkill command combines the functionality of pgrep and kill - it finds processes by name and sends a signal to them:
## Start two sleep processes
sleep 300 &
sleep 300 &
## Kill all sleep processes
pkill sleep
Verify that all sleep processes have been terminated:
ps | grep sleep
The killall Command
Similar to pkill, the killall command terminates processes by name:
## Start two more sleep processes
sleep 300 &
sleep 300 &
## Kill all sleep processes
killall sleep
Verify once more:
ps | grep sleep
Process Priority with nice and renice
Linux also allows you to control the priority of processes using the nice and renice commands.
Let's start a process with a lower priority:
nice -n 10 sleep 300 &
The nice value ranges from -20 (highest priority) to 19 (lowest priority). The default is 0. Only the root user can set negative nice values.
You can change the priority of a running process using renice:
sleep_pid=$!
echo "Sleep process ID with lower priority: $sleep_pid"
renice -n 15 -p $sleep_pid
Let's check the new priority:
ps -o pid,nice,cmd -p $sleep_pid
Finally, terminate this process:
kill $sleep_pid
These advanced process management commands provide more efficient ways to manage multiple processes and control system resources, which is especially useful on busy systems or when troubleshooting performance issues.
Summary
In this lab, you have learned essential Linux process management skills that are valuable for system administration and troubleshooting:
Identifying Processes: You learned how to use the
pscommand to list running processes and find their Process IDs (PIDs).Terminating Processes: You practiced using the
killcommand to send termination signals to processes using their PIDs.Understanding Kill Signals: You explored different types of signals that can be sent to processes, including SIGTERM (15) for graceful termination and SIGKILL (9) for forced termination.
Advanced Process Management: You discovered more powerful tools like
pgrep,pkill, andkillallfor finding and terminating processes by name, as well as how to control process priority withniceandrenice.
These skills enable you to:
- Monitor system processes effectively
- Terminate unresponsive applications
- Manage system resources
- Troubleshoot performance issues
Process management is a fundamental aspect of Linux system administration, and the commands you learned in this lab are used daily by Linux administrators and users to maintain system performance and stability.
