A Comprehensive Guide to Executing Shell Commands in Background from Bash Scripts

Introduction

In Unix/Linux system administration, executing background tasks from scripts is common for improving efficiency or enabling parallel processing. When commands are stored in string variables, special attention must be paid to execution methods to avoid syntax errors or unexpected behavior. This article systematically explores this issue based on high-quality Q&A from Stack Overflow.

Core Problem Analysis

The original poster attempted the following code:

#!/bin/bash
cmd="nohup mycommand";
other_cmd="nohup othercommand";

"$cmd &";
"$othercmd &";

This approach fails because the & inside quotes is treated as part of the string rather than a background operator. During Bash parsing, the entire "$cmd &" is seen as a command string to execute, but it contains spaces and special characters, leading to syntax errors.

Optimal Solution

According to the accepted best answer, the correct approach is to omit the quotes:

$cmd &
$othercmd &

When variables are expanded, Bash correctly interprets & as a background operator. Example demonstration:

#!/bin/bash

cmd="ls -la"

$cmd &

After execution, ls -la runs in the background, with output potentially appearing later in the terminal. This method is straightforward and suitable for most scenarios.

Technical Details Deep Dive

Variable Expansion Mechanism

In Bash, $cmd triggers variable expansion, replacing the variable value with ls -la. Subsequently, the command line becomes ls -la &, and Bash correctly recognizes & as a job control operator.

Comparison with Quote Usage

Comparing two approaches:

# Incorrect: quotes prevent proper parsing of &
"$cmd &"

# Correct: variable expansion forms a valid command
$cmd &

Quotes are typically used to protect arguments containing spaces or special characters, but in this context, they overprotect &, causing it to lose its special meaning.

Advanced Applications and Supplementary Methods

Complete Background Execution

Referencing other answers, if a command needs to fully detach from the terminal (hiding output and surviving terminal closure), combine redirection and disown:

cmd="google-chrome"
eval "${cmd}" &>/dev/null & disown

Here:

• &>/dev/null redirects stdout and stderr to the null device
• & places the command in the background
• disown removes the process from job control

Considerations for Using eval

In some scenarios, eval "${cmd}" is safer than direct expansion, particularly when commands contain complex quoting or nested variables. However, use it cautiously to avoid security risks.

Practical Recommendations

1. Simple Commands: Use $cmd & directly for simplicity and efficiency
2. Redirection Needed: Explicitly specify redirection targets, e.g., $cmd > output.log 2>&1 &
3. Long-Running Tasks: Consider combining with nohup or disown to prevent terminal closure effects
4. Error Handling: Add appropriate error checks to ensure background tasks start successfully

Conclusion

The key to executing string commands in the background from Bash scripts lies in correctly understanding the order of variable expansion and operator parsing. Omitting quotes allows & to be recognized as a background operator, while advanced needs can be met through redirection and job control commands. Developers should choose appropriate methods based on specific contexts and be mindful of security issues such as command injection.