Differences Between nohup, disown, and & in Linux

In the world of Linux, managing processes efficiently is crucial for system administrators. Three common tools that help in managing long-running processes are nohup, disown, and the & operator. Each serves a unique purpose but they are often used in conjunction to manage background processes and ensure they continue running even after a user has logged out. Let’s delve into the details of each, explore their differences and similarities, and share some tips and tricks for using them effectively.

What is nohup?

nohup, short for “no hang up,” is a command that is used to run another command that ignores the HUP (hangup) signal. This signal is sent to a process when its controlling terminal is closed (for example, when the user logs out). By ignoring this signal, the process continues running in the background even after the user logs out.

Syntax:

nohup command-to-run &

Example:

nohup python script.py &

Tips and Tricks:

• Output redirection: By default, nohup redirects the standard output to a file named nohup.out if no output file is specified. You can redirect the output to a file of your choice:

nohup python script.py > output.log &

• Combine with & to run the process completely in the background.

What is disown?

disown is a shell builtin command that removes a shell job from the shell’s job table, making it no longer a child of the shell. This means the process will not receive a HUP signal from the shell when the shell session is terminated.

Usage:

• Start a process in the background:

python script.py &

• Use jobs to see the job running in the background:

jobs

• Disown the job:

disown %1

Tips and Tricks:

• Use disown with a specific job number to remove only that job from the shell’s job table.

• You can use disown -a to remove all jobs from the job table.

What is &?

The & operator in Linux is used to put a command in the background. It’s a way to start a process and return immediately to the shell prompt, without waiting for the process to complete.

Example:

python script.py &

Tips and Tricks:

• Combine & with nohup or disown to run processes in the background that will survive your logout.

• Use fg to bring a background process to the foreground if needed:

fg %1

Differences and Similarities

• Similarities: All three methods (nohup, disown, and &) are used for managing background processes in Linux.

• Differences:

• nohup is used to run a command that ignores the hangup signal and is often used with & to run it in the background.

• disown is used to remove a job from the shell’s job table, ensuring it continues running without being attached to a specific terminal.

• & simply puts a command in the background but does not protect it from hangup signals.

Understanding the nuances of nohup, disown, and & can greatly enhance your ability to manage processes on a Linux system. Each tool has its specific use case, and knowing when and how to use them can make your system administration tasks more efficient. Whether you are running scripts that take a long time to complete or setting up services that should run continuously, these tools are indispensable in a Linux environment.

Related Reading

• Finding the PID of a Process Using a Specific Port in Linux
• Archive & Compression utilities
• Bash for loops sequential counting
• Bulk File Renaming on Linux: rename, vidir, fd
• Directory FileCount

The Gotchas Nobody Warns You About

Knowing what these tools do is great. Knowing where they’ll quietly betray you is better.

nohup.out will eat your disk if you forget about it

Run a chatty process with nohup and walk away. Come back a week later and find a nohup.out file the size of a small country sitting in whatever directory you launched it from. The fix is obvious in hindsight:

# Redirect stdout and stderr both — nohup.out won't be created at all
nohup python long_running_script.py > /var/log/myscript.log 2>&1 &

# Or send everything to /dev/null if you genuinely don't care
nohup python long_running_script.py > /dev/null 2>&1 &

The 2>&1 part redirects stderr to wherever stdout is going. Skipping it means errors still land in nohup.out while your script thinks it’s writing to the log. Classic.

disown doesn’t work in non-interactive shells

If you’re calling disown inside a script, it’ll fail silently or throw an error depending on the shell. disown is a shell builtin that only exists in interactive bash/zsh sessions — there’s no job table in a non-interactive script context. If you need persistent background processes from a script, nohup is your tool.

& with exit in a subshell will still kill your process

You backgrounded the job, you logged out, and it died anyway. Here’s a situation that catches people:

# This looks right but the subshell exit can still nuke the job
bash -c "long_running_thing &"

# Do this instead:
bash -c "nohup long_running_thing > /dev/null 2>&1 &"

The child process inherits SIGHUP from the parent shell when that shell exits. Without nohup in the mix, & alone isn’t enough protection.

The “I already started the process” rescue pattern

You launched something interactively and realized five minutes in that it’s going to take two hours. You don’t want to kill it and start over. Here’s the move:

# Suspend the foreground process
Ctrl+Z

# Send it to background
bg %1

# Now detach it from the shell so logout won't kill it
disown %1

# Verify it's gone from the job table
jobs

No PID hunting, no restart. This is the pattern that makes disown actually worth knowing — it’s the ejector seat for processes you forgot to nohup at launch.