How To Run A Command In The Background Linux

Sending a command to the background in Linux frees up your terminal for other tasks. If you have ever wondered how to run a command in the background linux, you are not alone. Many users need to execute long-running processes without keeping a terminal window open. This guide walks you through every method, from the ampersand to advanced tools like nohup and screen. You will learn practical steps to manage background tasks efficiently.

Background execution is a core Linux skill. It lets you run scripts, servers, or downloads while you continue working. The terminal stays responsive, and your system resources are used wisely. Let us start with the simplest technique and build up to more robust solutions.

Why Run Commands In The Background

Running commands in the background prevents your terminal from being blocked. When a foreground process runs, you cannot type new commands until it finishes. Background execution solves this. It also helps when you need to keep a process alive after logging out.

Common use cases include starting a web server, running a backup script, or processing large files. By backgrounding these tasks, you maintain control of your shell. You can also monitor multiple processes at once.

The most direct way to background a command is by appending an ampersand (&) at the end. This sends the process to run in the background immediately. Here is the syntax:

command &

For example, to run a sleep command in the background:

sleep 60 &

You will see a job number in brackets, like [1] 12345. The first number is the job ID, and the second is the process ID (PID). The command runs silently in the background. You can now type other commands in the same terminal.

This method works for most simple commands. However, if the command produces output, it may still appear in your terminal. To avoid this, redirect output to a file or /dev/null.

command > output.log 2>&1 &

This redirects both standard output and errors to a log file. The process runs quietly in the background.

Using The Ampersand With Multiple Commands

You can background several commands in one line. Separate them with semicolons or use && for conditional execution. For example:

command1 & command2 & command3 &

Each command runs in its own background process. This is useful for starting multiple services at once. Just remember that output may interleave, so redirect each command to a separate log file if needed.

Using The Disown Command

When you background a command with &, it remains attached to your terminal session. If you close the terminal, the process receives a hangup signal (SIGHUP) and stops. To prevent this, use the disown command.

First, background the process with &. Then run:

disown

This removes the job from the shell’s job table. The process continues running even after you log out. You can also disown a specific job by its job ID:

disown %1

Check job IDs with the jobs command. This method is simple but requires you to remember to run disown after backgrounding.

Disown With The -H Option

You can also prevent a background process from receiving SIGHUP by using disown -h. This marks the job so it ignores the hangup signal. The process stays in the job table but is protected.

command & disown -h %1

This is handy when you might need to bring the job back to the foreground later. However, for most cases, a full disown is simpler.

Using Nohup To Ignore Hangup Signals

The nohup command stands for “no hangup.” It runs a command immune to SIGHUP, even if you close the terminal. The syntax is straightforward:

nohup command &

Output is automatically redirected to a file named nohup.out in the current directory. You can specify a different output file:

nohup command > myoutput.log &

Nohup is ideal for long-running scripts or servers. It ensures your process survives terminal closure. However, it does not provide job control like bringing the process back to the foreground.

Nohup With Error Redirection

To capture errors separately, redirect stderr:

nohup command > out.log 2> err.log &

This keeps your output organized. You can check the log files later to see what happened. Nohup is a reliable tool for production environments.

Using The Screen Utility

Screen is a terminal multiplexer. It lets you create virtual terminal sessions that persist even after you disconnect. This is more powerful than simple backgrounding because you can reattach to the session later.

Install screen if it is not already present:

sudo apt install screen   # Debian/Ubuntu
sudo yum install screen   # RHEL/CentOS

Start a new screen session:

screen -S mysession

You are now inside a virtual terminal. Run your command normally:

./long-running-script.sh

Detach from the session by pressing Ctrl+A then D. The process continues running. Reattach later with:

screen -r mysession

You can have multiple sessions running simultaneously. List them with screen -ls. Screen is excellent for tasks that require interaction later.

Screen Commands Cheat Sheet

screen -S name – Create a named session
screen -r name – Reattach to a session
Ctrl+A D – Detach from current session
Ctrl+A C – Create a new window inside screen
Ctrl+A N – Switch to next window
screen -ls – List all sessions
screen -X -S name quit – Kill a session

Screen also supports scrollback and split windows. It is a versatile tool for managing background tasks.

Using Tmux As An Alternative

Tmux is another terminal multiplexer similar to screen. It is more modern and has a cleaner configuration. Install it with:

sudo apt install tmux

Start a new tmux session:

tmux new -s mysession

Run your command inside the session. Detach with Ctrl+B then D. Reattach with:

tmux attach -t mysession

Tmux supports panes and windows, making it great for complex workflows. It is widely used by developers and system administrators.

Basic Tmux Commands

tmux new -s name – New session
tmux attach -t name – Attach to session
Ctrl+B D – Detach
Ctrl+B C – Create new window
Ctrl+B , – Rename window
tmux ls – List sessions

Tmux is highly customizable. You can configure key bindings and status bars in ~/.tmux.conf. For most background tasks, either screen or tmux works well.

Using The At Command For One-Time Background Jobs

The at command schedules a command to run once at a specified time. It runs in the background and does not require a terminal. Install it if needed:

sudo apt install at

Schedule a job:

echo "command" | at 14:30

Or use interactive mode:

at 14:30
> command
> Ctrl+D

The job runs at the specified time. Output is emailed to you by default. Check scheduled jobs with atq and remove them with atrm.

At is useful for one-off tasks like a backup at midnight. It does not repeat, so for recurring jobs, use cron.

Using Cron For Recurring Background Tasks

Cron is the standard scheduler for recurring tasks. Edit your crontab with:

crontab -e

Add a line like this to run a command every day at 2 AM:

0 2 * * * /path/to/command

Cron jobs run in the background with no terminal. Output is emailed or can be redirected to a log file. This is perfect for maintenance scripts, backups, or updates.

Cron Syntax Basics

Minute (0-59)
Hour (0-23)
Day of month (1-31)
Month (1-12)
Day of week (0-7, where 0 and 7 are Sunday)

Example: 30 4 * * 1 /script.sh runs every Monday at 4:30 AM. Cron is reliable and widely used in production.

Managing Background Jobs With Jobs Command

The jobs command lists all background jobs in the current shell session. It shows job IDs, statuses, and commands. Use it to monitor your tasks:

jobs -l

This adds PIDs to the output. You can bring a job to the foreground with fg %1 or send it back to background with bg %1. The kill command can terminate a job by PID or job ID:

kill %1

These commands work only within the same terminal session. For processes started with nohup or disown, you need to use ps and kill by PID.

Using PS And Kill To Manage Background Processes

To see all processes running on your system, use ps aux. This shows every process with user, PID, CPU, and memory usage. Find your background process and note its PID.

Terminate it with:

kill PID

If the process does not stop, use kill -9 PID for a forceful kill. This is useful for stuck processes. You can also use pkill to kill by name:

pkill command_name

Be careful with pkill as it may match multiple processes. Always verify before killing.

Redirecting Output Properly

When running commands in the background, output can clutter your terminal. Always redirect stdout and stderr to files or /dev/null. Here are common patterns:

command > /dev/null 2>&1 &

This discards all output. For logging:

command > log.txt 2>&1 &

You can also append to a file with >>. Proper redirection keeps your terminal clean and helps with debugging later.

Common Pitfalls And Solutions

One common mistake is forgetting to redirect output. Your terminal may fill with messages. Always redirect when backgrounding.

Another issue is the process dying when you log out. Use nohup, disown, or a terminal multiplexer to prevent this. Also, check if your shell has the huponexit option set. In bash, you can disable it with shopt -u huponexit.

Sometimes background processes become zombies. Use ps aux | grep Z to find them. Zombies are usually harmless but indicate a parent process issue. Kill the parent to clean them up.

Real-World Examples

Here are practical scenarios where background execution shines:

Running a Python web server: nohup python3 -m http.server 8000 &
Starting a database: sudo service mysql start &
Compiling large software: make -j4 > build.log 2>&1 &
Downloading files with wget: wget -b url (built-in background)
Monitoring logs: tail -f /var/log/syslog &

Each of these keeps your terminal free. You can check progress later by viewing log files or reattaching to a screen session.

Choosing The Right Method

Your choice depends on the task. For quick commands that you can monitor, use & with output redirection. For tasks that must survive logout, use nohup or disown. For interactive or long-running tasks, use screen or tmux. For scheduled tasks, use at or cron.

Consider the following table for a quick reference:

Method	Best For	Survives Logout?
Ampersand (&)	Quick backgrounding	No
Disown	Removing from shell	Yes
Nohup	Hangup immunity	Yes
Screen/Tmux	Interactive sessions	Yes
At	One-time scheduling	Yes
Cron	Recurring tasks	Yes

Choose the tool that matches your workflow. Most Linux users combine several methods depending on the situation.

Frequently Asked Questions

What is the difference between nohup and disown?

Nohup runs a command with immunity to SIGHUP from the start. Disown removes a job from the shell’s job table after it is already running. Both prevent the process from dying when you log out, but nohup is simpler for new commands.

Can I bring a background process back to the foreground?

Yes, if you used & and did not disown it. Use the fg command followed by the job ID, like fg %1. For processes started with nohup or screen, you cannot bring them to the foreground directly, but you can reattach to a screen session.

How do I see all background processes?

Use the jobs command for jobs in your current shell. For all processes on the system, use ps aux or top. You can filter by user with ps -u username.

Does backgrounding improve performance?

No, backgrounding does not change CPU or memory usage. It only frees up your terminal. The process still uses the same resources. For performance, consider nice values or resource limits.

What happens if I close the terminal without disown?

The process receives a SIGHUP signal and terminates. To avoid this, use nohup, disown, screen, or tmux. Some shells have options to prevent this, but