Skip to main content

Understanding Signals in Linux

What are Signals?

In Linux, signals are software interruptions sent to programs and scripts to indicate that a specific event has occurred. They provide a way for processes and the operating system kernel to communicate, serving as a mechanism to inform a process that a specific event has occurred, so it can act accordingly.

Importance of Signals

Signals are critical for managing processes within Linux. They allow users and other processes to control and communicate with running processes, providing the ability to manage process execution, handling interruptions, and even terminating processes. By leveraging signals, users can interact with processes to ensure optimal system performance and resource allocation, manage errors and exceptions, and facilitate graceful termination and cleanup of processes.

The kill Command and its Syntax

The kill command is a tool in Linux used to send signals to processes. It allows users to send specific signals to a process, enabling control over process behavior, such as terminating, suspending, or continuing execution.

Syntax of the kill command:

kill [signal] PID
  • signal: The name or number of the signal you wish to send.
  • PID: The Process ID of the target process.

If the signal is not specified, the kill command will send the SIGTERM signal, requesting the process to terminate gracefully, allowing it to perform cleanup operations before exiting.

Types of Signals

There are various signals available to manage processes. Here’s a table illustrating some commonly used signals and their descriptions:

Signal NameShort FormDescription
SIGINTINTInterrupts the process, allowing it to terminate gracefully. It's sent when the user presses Ctrl+C.
SIGTERMTERMRequests a process to terminate but allows it to perform cleanup operations before terminating. It's the default signal sent by the kill command.
SIGKILLKILLForces the process to terminate immediately. This signal cannot be caught, blocked, or ignored.
SIGHUPHUPTypically sent when the terminal that started the process is closed. It allows the process to perform cleanup operations before terminating.
SIGSTOPSTOPPauses the process. This signal cannot be caught, blocked, or ignored.
SIGCONTCONTContinues a stopped process.
SIGTSTPTSTPPauses the process and places it into the background. It's typically initiated by the user pressing Ctrl+Z.
SIGSEGVSEGVSent to a process when it makes an invalid memory reference or segmentation fault.
SIGQUITQUITCauses the process to terminate and dump core. It's usually initiated by the user pressing Ctrl+\.
SIGWINCHWINCHSent to a process to inform it that the window has changed size.

Using Signals with the kill Command

The kill command can send various signals to manage processes effectively. Here's how you can use signals with the kill command to manage processes in Linux.

  • Sending the STOP Signal to Pause a Process:

    kill -STOP [PID]

    The STOP signal pauses the specified process, releasing system resources, and allowing other processes to execute.

  • Sending the CONT Signal to Resume a Process:

    kill -CONT [PID]

    The CONT signal resumes a paused process, allowing it to continue its execution.

  • Sending the TERM Signal to Terminate a Process Gracefully:

    kill -TERM [PID]

    The TERM signal requests a process to terminate but allows it to perform cleanup operations before exiting.

  • Sending the KILL Signal to Forcefully Terminate a Process:

    kill -KILL [PID]

    The KILL signal forcefully terminates the specified process without allowing it to perform any cleanup operations.

Using the killall Command

The killall command is another efficient tool that allows you to send a signal to multiple processes by specifying the name of the process instead of the Process ID. It is especially handy when you need to manage multiple instances of a process running simultaneously.

Demonstrating the killall Command

Let's create multiple instances of a process and use the killall command to send signals to them.

  1. Create Multiple Processes: For demonstration purposes, let's use gedit (a text editor) as our process. To open multiple instances of gedit, you can run the following commands in the terminal:

    gedit instance1 &
    gedit instance2 &
    gedit instance3 &

    The & symbol runs the process in the background, allowing you to continue using the terminal.

  2. List the Processes: To list all instances of gedit running on your system, you can use the pgrep command:

    pgrep -a gedit

    The output will list the Process IDs and names of all running gedit instances.

  3. Using killall to Send Signals: To send a signal to all instances of a particular process, you use the killall command followed by the signal and the process name.

    killall -s SIGTERM gedit

    This command will send the SIGTERM signal to all running gedit instances, requesting them to terminate gracefully.

    Similarly, to forcefully terminate all gedit processes, you can use:

    killall -s SIGKILL gedit


Signals are a fundamental aspect of process management in Linux, allowing for communication and control over running processes. They enable users to manage processes effectively, ensuring optimal resource utilization, error management, and system stability. The kill command is an invaluable tool for sending signals to processes, offering versatile options to control process execution, from pausing and resuming to graceful and forceful termination. By understanding and utilizing signals, users can enhance their proficiency in Linux process management, contributing to more efficient and robust system operation.

What Can You Do Next 🙏😊

If you liked the article, consider subscribing to Cloudaffle, my YouTube Channel, where I keep posting in-depth tutorials and all edutainment stuff for software developers.

YouTube @cloudaffle