Most of the time we login to remote server using ssh. If you start a shell script and you logout then the process is killed. Nohup helps to continue running the script in background even after you log out from shell.
Nohup command name &
eg: nohup sh script.sh &
Nohup catches the HUP signals. Nohup doesn't put the job automatically in the background. We need to tell that explicitly using &
The nohup command is a signal masking utility and catches the hangup signal. Where as ampersand doesn’t catch the hang up signals. The shell will terminate the sub command with the hang up signal when running a command using & and exiting the shell. This can be prevented by using nohup, as it catches the signal. Nohup command accept hang up signal which can be sent to a process by the kernel and block them. Nohup command is helpful in when a user wants to start long running application log out or close the window in which the process was initiated. Either of these actions normally prompts the kernel to hang up on the application, but a nohup wrapper will allow the process to continue. Using the ampersand will run the command in a child process and this child of the current bash session. When you exit the session, all of the child processes of that process will be killed. The ampersand relates to job control for the active shell. This is useful for running a process in a session in the background.
Correct me if I'm wrong
nohup myprocess.out &
nohup catches the hangup signal, which mean it will send a process when terminal closed.
myprocess.out &
Process can run but will stopped once the terminal is closed.
nohup myprocess.out
Process able to run even terminal closed, but you are able to stop the process by pressing ctrl + z in terminal. Crt +z not working if & is existing.
Using the ampersand (&) will run the command in a child process (child to the current bash session). However, when you exit the session, all child processes will be killed.
using nohup + ampersand (&) will do the same thing, except that when the session ends, the parent of the child process will be changed to "1" which is the "init" process, thus preserving the child from being killed.
There are many cases when small differences between environments can bite you. This is one into which I have ran recently. What is the difference between these two commands?
1 ~ $ nohup myprocess.out &
2 ~ $ myprocess.out &
The answer is the same as usual - it depends.
nohup catches the hangup signal while the ampersand does not.
What is the hangup signal?
SIGHUP - hangup detected on controlling terminal or death of controlling process (value: 1).
Normally, when running a command using & and exiting the shell afterwards, the shell will terminate the sub-command with the hangup signal (like kill -SIGHUP $PID). This can be prevented using nohup, as it catches the signal and ignores it so that it never reaches the actual application.
Fine, but like in this case there are always ‘buts’. There is no difference between these launching methods when the shell is configured in a way where it does not send SIGHUP at all.
In case you are using bash, you can use the command specified below to find out whether your shell sends SIGHUP to its child processes or not:
~ $ shopt | grep hupon
And moreover - there are cases where nohup does not work. For example, when the process you start reconnects the NOHUP signal (it is done inside, on the application code level).
In the described case, lack of differences bit me when inside a custom service launching script there was a call to a second script which sets up and launches the proper application without a nohup command.
On one Linux environment everything worked smoothly, on a second one the application quit as soon as the second script exited (detecting that case, of course took me much more time then you might think :stuck_out_tongue:).
After adding nohup as a launching method to second script, application keeps running even if the scripts will exit and this behavior became consistent on both environments.
myprocess.out & would run the process in background using a subshell. If the current shell is terminated (say by logout), all subshells are also terminated so the background process would also be terminated. The nohup command ignores the HUP signal and thus even if the current shell is terminated, the subshell and myprocess.out would continue to run in the background. Another difference is that & alone doesn't redirect the stdout/stderr so if there are any output or error, those are displayed on the terminal. nohup on the other hand redirect the stdout/stderr to nohup.out or $HOME/nohup.out.
Source: Stackoverflow.com