wait for background processes in Bash Scripting - Mini Project: Build & Apply

Wait for Background Processes in Bash

📖 Scenario: You are writing a Bash script to run multiple tasks in the background. You want to make sure the script waits until all these background tasks finish before moving on.

🎯 Goal: Build a Bash script that starts two background processes and then waits for both to complete before printing a final message.

📋 What You'll Learn

Create two background processes using sleep commands

Use the wait command to pause the script until both background processes finish

Print a message after all background processes have completed

💡 Why This Matters

🌍 Real World

Scripts often run multiple tasks at once to save time. Waiting ensures the script only continues after all tasks finish.

💼 Career

Knowing how to manage background processes and synchronization is important for system administrators and automation engineers.

1

Start two background processes

Create two background processes by running sleep 3 & and sleep 5 & in your script.

Bash Scripting

# Start two background sleep commands
# Your code here

Hint

Use the & symbol after a command to run it in the background.

2

Add a wait command

Add the wait command to your script to pause execution until all background processes finish.

Bash Scripting

sleep 3 &
sleep 5 &
# Add wait command below
# Your code here

Hint

The wait command waits for all background jobs to complete.

3

Print a completion message

After the wait command, add a echo statement to print "All background processes finished".

Bash Scripting

sleep 3 &
sleep 5 &
wait
# Print completion message below
# Your code here

Hint

Use echo to display messages in Bash.

4

Run the script and see the output

Run the complete script and observe that it waits about 5 seconds before printing All background processes finished.

Bash Scripting

sleep 3 &
sleep 5 &
wait
echo "All background processes finished"  # Run the script to see output

Hint

The script should pause until both sleep commands finish, then print the message.

Practice

1. What does the wait command do in a bash script when used without any arguments?

easy

A. It pauses the script until all background processes finish.

B. It immediately terminates all background processes.

C. It lists all running background processes.

D. It restarts the last background process.

Solution

1. Step 1: Understand the role of wait without arguments

   The wait command without arguments pauses the script until all background jobs started by the script finish.

2. Step 2: Compare with other options

   It does not terminate, list, or restart processes; it only waits for their completion.

3. Final Answer:

   It pauses the script until all background processes finish. -> Option A

4. Quick Check:

   wait without args = pause for all background jobs [OK]

Hint: No args means wait for all background jobs to finish [OK]

Common Mistakes:

• Thinking wait kills processes
• Assuming wait lists processes
• Confusing wait with restart commands

2. Which of the following is the correct syntax to wait for a specific background process with PID stored in variable pid?

easy

A. wait pid

B. wait $pid

C. wait --pid $pid

D. wait -p $pid

Solution

1. Step 1: Recall the syntax for waiting on a specific PID

   The correct syntax is wait $pid, where $pid is the process ID variable.

2. Step 2: Identify incorrect options

   Options with flags like -p or --pid are invalid in bash. Also, wait pid without $ won't expand the variable.

3. Final Answer:

   wait $pid -> Option B

4. Quick Check:

   Use wait with $pid to wait for that process [OK]

Hint: Use wait followed by $pid to wait for one process [OK]

Common Mistakes:

• Using flags like -p or --pid which don't exist
• Forgetting the $ to expand variable
• Passing variable name without $

3. Consider this script snippet:

sleep 3 & pid1=$!
sleep 5 & pid2=$!
wait $pid1
echo "First done"
wait $pid2
echo "Second done"

What will be the order of printed lines?

medium

A. First done\nSecond done

B. Second done\nFirst done

C. First done\nFirst done

D. Second done\nSecond done

Solution

1. Step 1: Understand background jobs and wait order

   Two sleep commands run in background: one sleeps 3 seconds, the other 5 seconds. wait $pid1 waits for the 3-second sleep to finish first.

2. Step 2: Trace the echo outputs

   After the first wait, it prints "First done". Then it waits for the 5-second sleep and prints "Second done".

3. Final Answer:

   First done Second done -> Option A

4. Quick Check:

   Waits print in order of completion [OK]

Hint: Wait commands print in order of waited process completion [OK]

Common Mistakes:

• Assuming both echo print immediately
• Confusing order of wait calls
• Ignoring background process durations

4. What is wrong with this script snippet?

sleep 4 &
wait pid
echo "Done"

Assuming pid is not defined.

medium

A. The script will wait for all background jobs anyway.

B. The script will wait for a process named 'pid'.

C. The script will throw an error because pid is undefined.

D. The script will ignore the wait command.

Solution

1. Step 1: Check variable usage in wait command

   The script uses wait pid without a $ sign, so bash treats 'pid' as a literal string, not a variable.

2. Step 2: Understand effect of undefined variable

   Since 'pid' is not a valid PID and not defined, wait will fail with an error about invalid PID or job.

3. Final Answer:

   The script will throw an error because pid is undefined. -> Option C

4. Quick Check:

   Use $pid to expand variable; missing $ causes error [OK]

Hint: Always use $ before variable names in wait [OK]

Common Mistakes:

• Forgetting $ before variable
• Assuming wait accepts names
• Ignoring error messages

5. You want to run three commands in background, capture their PIDs, and then wait specifically for those three processes to finish before continuing. Which script snippet correctly does this?

hard

A. cmd1 & pid1=$!; cmd2 & pid2=$!; cmd3 & pid3=$!; wait

B. cmd1 & cmd2 & cmd3 & wait $!

C. cmd1 & cmd2 & cmd3 & wait

D. cmd1 & pid1=$!; cmd2 & pid2=$!; cmd3 & pid3=$!; wait $pid1 $pid2 $pid3

Solution

1. Step 1: Understand background process tracking

   Each command runs in background and its PID is saved in separate variables.

2. Step 2: Use wait with all PIDs

   Using wait $pid1 $pid2 $pid3 waits for all three specific processes to finish.

3. Step 3: Analyze other options

   cmd1 & cmd2 & cmd3 & wait $! (cmd1 & cmd2 & cmd3 & wait $!) waits only for last background job. cmd1 & cmd2 & cmd3 & wait (cmd1 & cmd2 & cmd3 & wait) waits for all background jobs but does not track PIDs explicitly. cmd1 & pid1=$!; cmd2 & pid2=$!; cmd3 & pid3=$!; wait saves PIDs but then uses wait without arguments, so the PID variables are unused and it waits for all jobs.

4. Final Answer:

   cmd1 & pid1=$!; cmd2 & pid2=$!; cmd3 & pid3=$!; wait $pid1 $pid2 $pid3 -> Option D

5. Quick Check:

   Wait with all PIDs ensures all specific jobs finish [OK]

Hint: Save PIDs and wait for all to ensure completion [OK]

Common Mistakes:

• Waiting only for last PID
• Not saving PIDs before wait
• Assuming wait without args always works as expected