Running process to background linux

How can I put the current running linux process in background? [closed]

I have a command that uploads files using git to a remote server from the Linux shell and it will take many hours to finish. How can I put that running program in background? So that I can still work on shell and that process also gets completed?

The command is already running so i dont have other option. I am not sure which command to try. i didn’t wanted to break the current process so i didn’t experimented it

We should wait a more professional answer then 🙂 I meant if you had the chance to start all over again. ( The command & thing)

The accepted answerer on this question explains the three steps which needs to be taken: stackoverflow.com/questions/625409/…

You can also just open a second instance of putty and connect to the server again to get another shell. Though the solution with ctrl+z is great.

1 Answer 1

Suspend the process with CTRL+Z then use the command bg to resume it in background. For example:

sleep 60 ^Z #Suspend character shown after hitting CTRL+Z [1]+ Stopped sleep 60 #Message showing stopped process info bg #Resume current job (last job stopped) 

More about job control and bg usage in bash manual page:

JOB CONTROL
Typing the suspend character (typically ^Z, Control-Z) while a process is running causes that process to be stopped and returns control to bash. [. ] The user may then manipulate the state of this job, using the bg command to continue it in the background, [. ]. A ^Z takes effect immediately, and has the additional side effect of causing pending output and typeahead to be discarded.

bg [jobspec . ]
Resume each suspended job jobspec in the background, as if it had been started with &. If jobspec is not present, the shell’s notion of the current job is used.

To start a process where you can even kill the terminal and it still carries on running

nohup [command] [-args] > [filename] 2>&1 & 

nohup /home/edheal/myprog -arg1 -arg2 > /home/edheal/output.txt 2>&1 & 

To just ignore the output (not very wise) change the filename to /dev/null

To get the error message set to a different file change the &1 to a filename.

In addition: You can use the jobs command to see an indexed list of those backgrounded processes. And you can kill a backgrounded process by running kill %1 or kill %2 with the number being the index of the process.

Источник

Send a Process to Background Linux

When working with graphical desktop environments, we rarely worry about background processes. If we have a process running in the foreground, we can quickly spawn another terminal window and continue with our work.

However, if you are in a raw terminal shell such as SSH, you will often feel concerned about processes that occupy and block the shell until they are completed, especially on long-running jobs. That is where the concept of background and foreground processes comes into play.

This tutorial will discuss what background and foreground processes are, including creating and managing them in Linux.

What is a Process?

Allow me to start at the basic level: what is a process?

In Linux, a process is an instance of a program. Typically, this means any command or executable in a shell is a process.

There are mainly two types of processes:

Foreground processes are mainly typical applications that we launch and interact with them. An example would be the nautilus file manager in Gnome. In most cases, we can start foreground processes from the shell or the desktop environment.

On the other hand, background processes run in the background and require no input or interaction from the user. An example would be any typical Linux daemon.

How to Run a Process in the Background

Suppose we have a process that, while running, occupies the shell session and hinders us from executing commands until it exits.

For example, if we run the Firefox browser in the shell, it will occupy the session until process termination.

As you can see, as long as Firefox is running, the shell prompt is unavailable, and we cannot execute any more commands.

To solve this, we can do it two ways:

1: Using an Ampersand (&)

The first method is using the ampersand & sign. This tells the shell to run whatever command precedes the ampersand in the background.

In such a scenario, the process executes in the background and spawns as a new shell prompt allowing us to continue executing commands.

It also gives two numerical identifiers. The first one enclosed in square brackets is the Job ID, while the next one is the process ID.

2: Using CTRL + Z, bg command.

The next method you can use to put a process in the background is to use the shortcut CTRL + Z. This stops the process from blocking the shell. You can then use the bg command to push it to the background.

For example, start by launching Firefox as:

While the process is running, press CTRL + Z. This returns your shell prompt. Finally, enter the bg command to push the process in the background.

How to Show Background Processes

To view and manage processes in the background, use the jobs command in the shell. That will show the background jobs in the current terminal session.

An example output of background jobs:

To bring a process running in the background to the foreground, use the fg command followed by the job id.

For example, to bring the firefox job in the foreground, we use the command:

To put in the background again, press CTRL + Z followed by the bg command.

How to Make a Process Persistent After Shell Dies

When you are running processes in the background, and your shell session dies, all the processes associated with it terminate, which can be problematic, especially if it is an SSH session.

However, this is not too big an issue if you use a terminal multiplexer such as tmux or screen because, in that case, you can simply reattach the session.

However, if you run a shell session without a multiplexer, you can use the nohup command.

The nohup command is immune to hang-ups and can ignore the SIGHUP signal sent to a process.

Hence, if you run a command with nohup, it continues to run even if the shell session accidentally dies.

For example, to run Firefox with nohup, use the command:

This will run the process in the background as persist a shell terminate.

You can run a new terminal session and view the background jobs. You will see the process still running in the background.

Conclusion

In this tutorial, we discussed various ways to run and send processes to the background in Linux. We also covered how to bring a background process to the background and persist hang-up upon shell termination.

About the author

John Otieno

My name is John and am a fellow geek like you. I am passionate about all things computers from Hardware, Operating systems to Programming. My dream is to share my knowledge with the world and help out fellow geeks. Follow my content by subscribing to LinuxHint mailing list

Источник

linux — running process background

I want to run a process in a remote linux server and keep that process alive after close the putty terminal, what is the correct command?

4 Answers 4

1. Use GNU screen, which will allow you to run the command and detach it from your terminal, and later re-attach it to a different session. I use it for long-running processes whose output I want to be able to monitor at any time. Screen is a truly powerful tool and I would highly recommend spending some time to learn it.
2. Run the command as nohup some-command & , which will run the command in the background, detach it from the console, and redirect its output into nohup.out . It will swallow SIGHUPs that are sent to the process. (When you close the terminal or log out, SIGHUP is sent to all processes that were started by the login shell, and the default action the kernel will take is to kill the process off. This is why appending & to put the process in the background is not enough for it to survive a logout.)

don’t use that nohup junk, i hate seeing that on servers; screen is a wasting pile of bits and rot — use tmux.

if you want to background a process, double fork like every other daemon since the beginning of time:

# ((exec sleep 30)&) # grep PPid /proc/`pgrep sleep`/status PPid: 1 # jobs # disown bash: disown: current: no such job 

well, not urgent i suppose, unless being pointless meets the requirements. using nohup for this task is a workaround to a 100% non-issue. i have no idea how/why nohup became the commonplace «solution», nor do i know of a technical limitation to the method outlined above. a double-fork is clean, fast (avoids a fork, should it matter), retains the use of SIGHUP proper, and works on any shell since ~30yrs. while i can’t cite details off-hand, nohup bit me a few times when unknowingly ran applications under it that made legitimate use of SIGHUP (of which there are many).

The modern and easy to use approach that allows managing multiple processes and has a nice terminal UI is hapless utility.

Install with pip install hapless (or python3 -m pip install hapless ) and just run

$ hap run my-command # e.g. hap run python my_long_running_script.py $ hap status # check all the launched processes 

Источник