Killing job in linux

How to manage jobs in Linux – fg bg kill Ctrl+Z

How many times did you start something which is time consuming and waited for it to end until you could use the console again. We have all faced a situtation when we just stare at the screen for a process to get over after we have initiated it. It could be something as simple as copying a large file from a removable media or installing packages using yum/apt-get from online repositories over a slow internet connection (ouch!). Once started you will not get back the command shell until the process is done, so what do you do ? Hit Ctrl+C terminate it and hope to do it over the weekend ? Take a coffee break ? Count the number of keys on the keyboard ? Why not press Ctrl+Z and get the work done in background while you use the console to do something else. In this article I will cover how to suspend a process a.k.a. job, run it in the background, bring it to the foreground, terminate it if necessary.

Viewing the status of jobs

The “jobs” command will display background jobs and their current status.

# jobs
[1]+ Stopped apt-get upgrade
[2]- Running dd if=/dev/zero of=dummyfile bs=1K count=2048000 &

Executing a job in the background

If you are well aware that something will take a long time to finish why not start it in the background itself. Just adding an ampersand (&) after the command will execute it in background.

cp /mnt/largefile /home/jesin/files/largefile.bak &

Moving a foreground job to the background

You have started something thinking it will end soon but it is taking an eternity to complete, just a simple Ctrl+Z is enough to move it back

# dd if=/dev/zero of=dummyfile bs=1K count=2048000
^Z
[1]+ Stopped dd if=/dev/zero of=dummyfile bs=1K count=2048000

That ^Z denotes hitting Ctrl+Z. Now that the job is stopped use the bg command to run it in the background.

The number “1” is the ID of the job as viewed under the jobs command it must be preceded with a “%”

Moving a background job to the foreground

To bring a job running in the background to the foreground use the fg command

Terminating a job

Terminating or killing a job can be done using the “kill” command. But wait a minute isn’t this command used to terminate processes ? Yes it is so it all depends on the argument passed. The job number should be entered preceded by a percentage symbol (%)

Be very careful not to miss the percentage symbol, miss it and you will end up terminating PID 1 which is “init” or PID 2 which is “kthreadd” terminating any of these will make your life miserable.

Suspend a background job

Now this is a bit tricky as there is no direct command to make this happen, you need to use a couple of commands to stop a process running in the background. The process we follow is this – note the jobID, bring the job to the foreground, press CTRL+Z to suspend it.

# jobs
[1]+ Running dd if=/dev/zero of=dummyfile bs=1K count=2048000 &
root@debian:

# fg %1
^Z
[1]+ Stopped dd if=/dev/zero of=dummyfile bs=1K count=2048000

Источник

Job Control

In the previous lesson, we looked at some of the implications of Linux being a multi-user operating system. In this lesson, we will examine the multitasking nature of Linux, and how it is controlled with the command line interface.

As with any multitasking operating system, Linux executes multiple, simultaneous processes. Well, they appear simultaneous, anyway. Actually, a single processor core can only execute one process at a time but the Linux kernel manages to give each process its turn at the processor and each appears to be running at the same time.

There are several commands that are used to control processes. They are:

• ps — list the processes running on the system
• kill — send a signal to one or more processes (usually to «kill» a process)
• jobs — an alternate way of listing your own processes
• bg — put a process in the background
• fg — put a process in the foreground

A Practical Example

While it may seem that this subject is rather obscure, it can be very practical for the average user who mostly works with the graphical user interface. Though it might not be apparent, most (if not all) graphical programs can be launched from the command line. Here’s an example: there is a small program supplied with the X Window system called xload which displays a graph representing system load. We can execute this program by typing the following:

Notice that the small xload window appears and begins to display the system load graph. On systems where xload is not available, try gedit instead. Notice also that our prompt did not reappear after the program launched. The shell is waiting for the program to finish before control returns. If we close the xload window, the xload program terminates and the prompt returns.

Putting a Program into the Background

Now, in order to make life a little easier, we are going to launch the xload program again, but this time we will put it in the background so that the prompt will return. To do this, we execute xload like this:

In this case, the prompt returned because the process was put in the background.

Now imagine that we forgot to use the «&» symbol to put the program into the background. There is still hope. We can type Ctrl-z and the process will be suspended. We can verify this by seeing that the program’s window is frozen. The process still exists, but is idle. To resume the process in the background, type the bg command (short for background). Here is an example:

Listing Running Processes

Now that we have a process in the background, it would be helpful to display a list of the processes we have launched. To do this, we can use either the jobs command or the more powerful ps command.

Killing a Process

Suppose that we have a program that becomes unresponsive; how do we get rid of it? We use the kill command, of course. Let’s try this out on xload . First, we need to identify the process we want to kill. We can use either jobs or ps , to do this. If we use jobs we will get back a job number. With ps , we are given a process id (PID). We will do it both ways:

A Little More About kill

While the kill command is used to «kill» processes, its real purpose is to send signals to processes. Most of the time the signal is intended to tell the process to go away, but there is more to it than that. Programs (if they are properly written) listen for signals from the operating system and respond to them, most often to allow some graceful method of terminating. For example, a text editor might listen for any signal that indicates that the user is logging off, or that the computer is shutting down. When it receives this signal, it could save the work in progress before it exits. The kill command can send a variety of signals to processes. Typing:

will print a list of the signals it supports. Many are rather obscure, but several are handy to know:

Signal #	Name	Description
1	SIGHUP	Hang up signal. Programs can listen for this signal and act upon it. This signal is sent to processes running in a terminal when you close the terminal.
2	SIGINT	Interrupt signal. This signal is given to processes to interrupt them. Programs can process this signal and act upon it. We can also issue this signal directly by typing Ctrl-c in the terminal window where the program is running.
15	SIGTERM	Termination signal. This signal is given to processes to terminate them. Again, programs can process this signal and act upon it. This is the default signal sent by the kill command if no signal is specified.
9	SIGKILL	Kill signal. This signal causes the immediate termination of the process by the Linux kernel. Programs cannot listen for this signal.

Now let’s suppose that we have a program that is hopelessly hung and we want to get rid of it. Here’s what we do:

1. Use the ps command to get the process id (PID) of the process we want to terminate.
2. Issue a kill command for that PID.
3. If the process refuses to terminate (i.e., it is ignoring the signal), send increasingly harsh signals until it does terminate.

In the example above we used the ps command with the x option to list all of our processes (even those not launched from the current terminal). In addition, we piped the output of the ps command into grep to list only list the program we are interested in. Next, we used kill to issue a SIGTERM signal to the troublesome program. In actual practice, it is more common to do it in the following way since the default signal sent by kill is SIGTERM and kill can also use the signal number instead of the signal name:

Then, if the process does not terminate, force it with the SIGKILL signal:

That’s It!

This concludes the «Learning the Shell» series of lessons. In the next series, «Writing Shell Scripts,» we will look at how to automate tasks with the shell.

Further Reading

• For a more in-depth treatment of the topic, see Chapter 10 in The Linux Command Line.
• 1963 Timesharing: A Solution to Computer Bottlenecks, a fascinating YouTube video from the Computer History Museum describing the first timesharing operating system and how it works. It’s basically the same method used by all modern computers.

© 2000-2021, William E. Shotts, Jr. Verbatim copying and distribution of this entire article is permitted in any medium, provided this copyright notice is preserved.

Linux® is a registered trademark of Linus Torvalds.

Источник

List and kill at jobs on UNIX

I have created a job with the at command on Solaris 10.

It’s working now but I want to kill it but I don’t know how I can find the job number and how to kill that job or process.

4 Answers 4

You should be able to find your command with a ps variant like:

Then, once located, it should be a simple matter to use kill to kill the process (permissions permitting).

If you’re talking about getting rid of jobs in the at queue (that aren’t running yet), you can use atq to list them and atrm to get rid of them.

To delete a job which has not yet run, you need the atrm command. You can use atq command to get its number in the at list.

To kill a job which has already started to run, you’ll need to grep for it using:

and then use kill to stop it.

A quicker way to do this on most systems is:

at -l to list jobs, which gives return like this:

atrm 10 kills job 10

Or so my sysadmin told me, and it

to list all processes. Note the the process number of the one you want to kill. Then

were you replace 1234 with the process number that you want.

Alternatively, if you are absolutely certain that there is only one process with a particular name, or you want to kill multiple processes which share the same name

Источник

How can I kill all stopped jobs?

When I try to exit from my Linux server I get the message:

There are stopped jobs.

: Is there a single command to kill these?

8 Answers 8

To quickly kill all the stopped jobs under the bash, enter:

jobs -ps lists the process IDs ( -p ) of the stopped ( -s ) jobs.
kill -9 `jobs -ps` sends SIGKILL signals to all of them.

Try typing this:

The accepted answer would kill all jobs (which is sufficient in this case) and not merely the stopped ones. Should you want to kill only the Stopped ones, run:

The easiest way is actually to simply immediately retry the exit; bash will take that to mean «kill all stopped jobs and exit».

Normally if you got that message, you need to logout twice. E.g. first Ctrl+D gives you the warning message to inform you about stopped jobs, pressing for the second time will log you out killing the jobs. This the same applies to logout and exit commands.

To kill them manually, try: kill $(jobs -p) .

If you don’t want to kill jobs from your current shell, you can remove them from the table of active jobs without killing by using disown command. E.g.

Stopped jobs also can be determined by the state of the process ( T character) which means the process was stopped by signal such as SIGSTOP , SIGTSTP or other (like SIGTTIN , or SIGTTOU ).

In case when jobs a shell builtin command is not available, stopped processes can be listed by the following command:

Источник

How to Kill a Process in Linux? Commands to Terminate

Home » SysAdmin » How to Kill a Process in Linux? Commands to Terminate

If a Linux process becomes unresponsive or is consuming too many resources, you may need to kill it.

Most processes have their own methods of shutting down. Unfortunately, processes can malfunction and not allow themselves to be shut down. If a running background process is unresponsive, it becomes necessary to use a command to kill it.

Here’s a complete guide on how to kill a Linux process using the command line.

What Processes Can You Kill in Linux?

Before killing or terminating a process, you need to consider permissions.

A root user can kill all processes. You can either add sudo before a command to run it as root, or obtain a root shell with su . Then execute the command.

Killing a process sends a termination message to the given process. There are multiple types of termination messages including:

• SIGKILL – SIGKILL is the ultimate way of killing a process. It will always kill a process and will kill the process abruptly, generating a fatal error. SIGKILL should always work. If it does not work, the operating system has failed.
• SIGTERM – SIGTERM attempts to kill a process, but unlike SIGKILL it may be blocked or otherwise handled. It can be considered a gentler way of attempting to terminate a process.

For most purposes, SIGKILL will be the fastest and most effective method to terminate the process.

Step 1: View Running Linux Processes

The top command is the easiest way to get a complete overview of the processes currently being run.

To view a list of all currently running processes, use the command:

The top command will reveal process IDs and users, in addition to the amount of memory and CPU power each process is using.

To kill processes directly from the top interface, press k and enter the process ID.

To exit the top interface, press q.

Step 2: Locate the Process to Kill

Before you can kill a process, you need to find it. There are multiple ways you can search for a process in Linux. Processes can either be located by a process name (or a partial process name) or a process ID (also known as a “pid”).

Locate a Process with ps Command

The ps command displays similar information to top , though it will not be in the form of an interface. Instead, the ps command provides a complete listing of running processes, formatted based on the tags you add.

The most common options to add to this is “-aux”:

• -a . View processes of all users rather than just the current user.
• -u . Provide detailed information about each of the processes
• -x . Include processes that are controlled not by users but by daemons.

For example, the command ps -aux will return a detailed process list of all processes.

Finding the PID with pgrep or pidof

The Linux command pgrep is a more complex way of finding a process. This command will return processes based on specific selection criteria, which is known as the pattern. The pattern is a regular expression, such as a* , where * would be a wildcard.

Here are the options that can be used with this command:

• -l . List both the process names and the PIDs.
• -n . Return the process that is newest.
• -o . Return the process that is oldest.
• -u . Only find processes that belong to a specific user.
• -x . Only find processes that exactly match the given pattern.

The command pgrep -u root displays all processes owned by root. The command pgrep -u root ‘a*’ returns processes owned by root that start with the letter “a”.

The pidof command is used to find the ID of a process, provided that you know the name of the process.

A few options can be included, such as:

• -c . Only return PIDs within a single root directory.
• -o . Omit certain PIDs (include the processes to omit after the flag).
• -s . Only return a single PID.
• -x . Also returns PIDs of shells that are running scripts.

Step 3: Use Kill Command Options to Terminate a Process

There are a few different methods of killing a process in Linux, depending on whether you know the name of the process running, the pid of the process, or just how long the process has been running.

killall Command

The killall command is used to kill processes by name. By default, it will send a SIGTERM signal. The killall command can kill multiple processes with a single command.

Several options can be used with the killall command:

• -e . Find an exact match for the process name.
• -I . Ignore case when trying to find the process name.
• -i . Ask for additional confirmation when killing the process.
• -u . Only kill processes owned by a specific user.
• -v . Report back on whether the process has been successfully killed.

In addition to killing processes based on name, the killall command can also be used to kill based on the age of the process, using the following commands:

• -o . Use this flag with a duration to kill all processes that have been running more than that amount of time.
• -y . Use this flag with a duration to kill all processes that have been running less than that amount of time.

The killall -o 15m command will kill all processes that are older than 15 minutes, while the killall -y 15m command will kill all processes that are less than 15 minutes.

pkill Command

The pkill command is similar to the pgrep command, in that it will kill a process based on the process name, in addition to other qualifying factors. By default, pkill will send the SIGTERM signal.

pkill options include:

• -n . Only kill the newest of the processes that are discovered.
• -o . Only kill the oldest of the processes that are discovered.
• -u . Only kill the processes that are owned by the selected user.
• -x . Only kill the processes that match the pattern exactly.
• -signal . Send a specific signal to the process, rather than SIGTERM.

kill Command

If you know a process ID, you can kill it with the command:

The kill command will kill a single process at a time with the given process ID. It will send a SIGTERM signal indicating to a process to stop. It waits for the program to run its shutdown routine.

The -signal command can be used to specify a signal that isn’t SIGTERM.

kill -9 Linux Command

kill -9 is a useful command when you need to shut down an unresponsive service. Run it similarly as a regular kill command:

The kill -9 command sends a SIGKILL signal indicating to a service to shut down immediately. An unresponsive program will ignore a kill command, but it will shut down whenever a kill -9 command is issued. Use this command with caution. It bypasses the standard shutdown routine so any unsaved data will be lost.

Your operating system is not running properly if a SIGKILL signal does not shut down a service.

top Command

The top command provides an interface through which a user can navigate through currently running processes.

To kill a specific process, insert k from the top interface and then enter in the desired process ID.

xkill command

The xkill command is a special type of command that closes a given server’s connection to clients.

If a server has opened a number of unwanted processes, xkill will abort these processes.

If xkill is run without specifying a resource, then an interface will open up that lets the user select a window to close.

Key Takeaways on Terminating a Linux Process

• When a process cannot be closed any other way, it can be manually killed via command line.
• To kill a process in Linux, you must first find the process. You can use the top , ps , pidof or pgrep commands.
• Once you have found the process you want to kill, you can kill it with the killall , pkill , kill , xkill or top commands.
• When killing a process, you can send a termination signal of SIGHUP, SIGKILL, or SIGTERM.
• You need to have permission to kill a process, which you can gain through the use of the sudo command.

In this article, we covered several ways to kill processes in Linux. It is critical to learn and understand these Linux termination commands for system management and administration.

Источник