Introduction

A Linux server, like any modern computer, runs multiple applications. These are referred to and managed as individual processes.

While Linux will handle the low-level, behind-the-scenes management in a process’s life-cycle – i.e., startup, shutdown, memory allocation, and so on – you will need a way of interacting with the operating system to manage them from a higher level.

In this guide, you will learn some fundamental aspects of process management. Linux provides a number of standard, built-in tools for this purpose

You will explore these ideas in a Ubuntu 20.04 environment, but any modern Linux distribution will operate in a similar way.

Step 1 – How To View Running Processes in Linux

You can see all of the processes running on your server by using the top command:

$ top

Output

top - 15:14:40 up 46 min, 1 user, load average: 0.00, 0.01, 0.05

Tasks: 56 total, 1 running, 55 sleeping, 0 stopped, 0 zombie

Cpu(s): 0.0%us, 0.0%sy, 0.0%ni,100.0%id, 0.0%wa, 0.0%hi, 0.0%si, 0.0%st

Mem: 1019600k total, 316576k used, 703024k free, 7652k buffers

Swap: 0k total, 0k used, 0k free, 258976k cached

The remainder of the displayed output shows the running processes and their usage statistics. By default, top automatically sorts these by CPU usage, so you can see the busiest processes first. top will continue running in your shell until you stop it using the standard key combination of Ctrl+C to exit a running process. This sends a kill signal, instructing the process to stop gracefully if it is able to

An improved version of top, called htop, is available in most package repositories. On Ubuntu 20.04, you can install it with apt:

$ htop

Output

Mem[||||||||||| 49/995MB] Load average: 0.00 0.03 0.05

CPU[ 0.0%] Tasks: 21, 3 thr; 1 running

Swp[ 0/0MB] Uptime: 00:58:11

PID USER PRI NI VIRT RES SHR S CPU% MEM% TIME+ Command

1259 root 20 0 25660 1880 1368 R 0.0 0.2 0:00.06 htop

htop provides better visualization of multiple CPU threads, better awareness of color support in modern terminals, and more sorting options, among other features. Unlike top, It is not always installed by default, but can be considered a drop-in-replacement. You can exit htop by pressing Ctrl+C as with top

Step 2 – How To Use ps to List Processes

top and htop provide a dashboard interface to view running processes similar to a graphical task manager. A dashboard interface can provide an overview, but usually does not return directly actionable output. For this, Linux provides another standard command called ps to query running processes.

Running ps without any arguments provides very little information:

$ ps
Output

PID TTY TIME CMD

1017 pts/0 00:00:00 bash

1262 pts/0 00:00:00 ps

A process’s parent is the process that was responsible for spawning it. Parent processes have a PPID, which you can see in the column headers in many process management applications, including top, htop and ps.

Any communication between the user and the operating system about processes involves translating between process names and PIDs at some point during the operation. This is why these utilities will always include the PID in their output. In the next section, you’ll learn how to use PIDs to send stop, resume, or other signals to running processes.

Step 3 – How To Send Processes Signals in Linux

All processes in Linux respond to signals. Signals are an operating system-level way of telling programs to terminate or modify their behavior

The most common way of passing signals to a program is with the kill command. As you might expect, the default functionality of this utility is to attempt to kill a process:

$ kill PID_of_target_process

>This sends the TERM signal to the process. The TERM signal tells the process to please terminate. This allows the program to perform clean-up operations and exit smoothly.

If the program is misbehaving and does not exit when given the TERM signal, you can escalate the signal by passing the KILL signal:

$ kill -KILL PID_of_target_process

For instance, many processes that are designed to run constantly in the background (sometimes called “daemons”) will automatically restart when they are given the HUP, or hang-up signal. The Apache webserver typically operates this way.

$ sudo kill -HUP pid_of_apache

You can list all of the signals that are possible to send with kill with the -l flag:

$ kill -l

Output SIGHUP,SIGINT,SIGQUIT,SIGILL,SIGTRAP

The pkill command works in almost exactly the same way as kill, but it operates on a process name instead:

$ pkill -9 ping

The above command is the equivalent of:

$ kill -9 `pgrep ping`

If you would like to send a signal to every instance of a certain process, you can use the killall command:

$ killall firefox

The above command will send the TERM signal to every instance of firefox running on the computer.

Step 4 – How To Adjust Process Priorities

When you ran top at the beginning of the article, there was a column marked “NI”. This is the nice value of the process:

$ top

Output

[secondary_label Output]

Tasks: 56 total, 1 running, 55 sleeping, 0 stopped, 0 zombie

Cpu(s): 0.0%us, 0.3%sy, 0.0%ni, 99.7%id, 0.0%wa, 0.0%hi, 0.0%si, 0.0%st

Mem: 1019600k total, 324496k used, 695104k free, 8512k buffers

Swap: 0k total, 0k used, 0k free, 264812k cached

Nice values can range between -19/-20 (highest priority) and 19/20 (lowest priority) depending on the system.

To run a program with a certain nice value, you can use the nice command:

$ nice -n 15 command_to_execute

This only works when beginning a new program.

To alter the nice value of a program that is already executing, you use a tool called renice:

$ renice 0 PID_to_prioritize

Conclusion

Process management is a fundamental part of Linux that is useful in almost every context. Even if you aren’t performing any hands-on system administration, being able to chase down stuck processes and handle them carefully is very helpful.