Bash “wait” Command in Process Management [6 Examples]

Using the “wait” command in Bash implies pausing the execution of a script until the background processes or jobs are completed. This command plays a crucial role in process management offering proper synchronization, error handling, flexible waiting, and proper termination capabilities for background processes.

In this article, I’ll show you how to use the “wait” command in Bash process management with different examples. Let’s delve into it!

What is “wait” Command in Bash?

The “wait” command is a built-in Bash shell command that waits for the completion of background processes launched within a script. It allows blocking the execution of the script until all the background processes get terminated. The basic syntax of the “wait” command is:

wait [PID]

Here, PID specifies the Process IDs of the background processes to wait for. If no PID is specified, the command waits for all background processes to complete.

6 Examples of Bash “wait” Command in Process Management

The “wait” command can be used in various scenarios in Bash Process Management. Following are 6 different examples of using the “wait” command in Bash such as waiting for a single background process, multiple background processes, the first background process, the background process within pipelines, and loops, and the trapping and executing cleanup actions.

1. Waiting for a Single Background Process in Bash

To wait for a single process to complete while it is running in the background, use the “wait” command like the following script:

#!/bin/bash

#Launching a background process
sleep 5 &
echo "A background process is running"
wait
echo "Process execution completed!"

The above image indicates that the process execution has been completed successfully.

2. Waiting for Multiple Background Processes in Bash

When multiple processes are running in the background, use the “wait” command without any argument (PID) to wait for all the processes to complete.

Here’s a script to wait for multiple processes in Bash:

#!/bin/bash

#Launching multiple background processes
sleep 2 &
sleep 3 &
sleep 4 &

echo "Multiple background processes are running"

#Waiting for all background processes to finish
wait

echo "Process execution completed!"

This image shows that all the process executions have been completed successfully.

Waiting for Multiple Processes with Specific PIDs

As each process running in the background includes a specific PID, you can use them as arguments of the “wait” command to wait for all those particular background processes to complete.

Check out the following script to wait for multiple background processes with specific PIDs:

#!/bin/bash

#Launching multiple background processes
sleep 3 &
pid1=$!  #Storing PID of the process
echo "Executing the first process with PID: $pid1"

sleep 6 &
pid2=$!  #Storing PID of the process
echo "Executing the second process with PID: $pid2"

#Waiting for specific background processes to finish
wait $pid1  #Waiting for the first process to finish
echo "First task completed."

wait $pid2  #Waiting for the second process to finish
echo "Second task completed."

echo "Process executed successfully"

From the image, you can see that all the processes with particular PIDs have been completed.

3. Waiting for Background Process within Pipelines

Piping (|) is helpful to run commands or processes sequentially in Bash. When you chain multiple processes using the pipe operator and use the “wait” command, the script waits for all background processes in the pipeline to complete before continuing the execution.

For example, first, create a file and add text:

file1.txt >

Linux distros:

Ubuntu
Red Hat
CentOS
Kali Linux

Now, see the following script to wait for the background process within pipelines in Bash:

#!/bin/bash

process1() {
    cat file1.txt
}
process2() {
    grep "Linux"
}
process3() {
    wc -l > file2.txt
}

#Starting pipelines
process1 | process2 | process3 &

#Waiting for the background process to finish
wait

echo "Process completed"

The image states that all processes in the pipeline have been completed.

4. Waiting for the First Process to Complete in a Bash Script

By default, the “wait” command waits for all background processes to finish. However, when the -n option is used with the “wait” command, it pauses the script’s execution and waits until any one of the background processes completes. After the process completion, the script continues its execution.

Check out the script below to wait for the first process to complete in Bash:

#!/bin/bash

#Simulating background process using a function
child_process() {
    local id=$1
    echo "Started child $id"
    sleep $((RANDOM % 6 + 1)) 
    echo "Completed child $id"
}

echo "Starting parent process $$"

#Starting three background processes
child_process 1 &
pid1=$!

child_process 2 &
pid2=$!

child_process 3 &
pid3=$!

#Waiting for the first background process to finish
wait -n

echo "Completed parent process's wait"

The image shows that the wait command exited after the completion of the first child process.

5. Iterative Waiting for Processes within a Loop

The “wait” command within a loop allows users to execute multiple background processes iteratively and wait for all the processes to finish before completing the script’s execution. It is useful to execute a similar task several times in a loop in Bash.

Following is an example of using the wait command within a loop in Bash:

#!/bin/bash

#Starting a loop
for n in {1..4}; do
    sleep $n &  #Sleeping for the value of $n seconds in the background
done

echo "Starting background processes"

#Waiting for all background processes to finish
wait

echo "Completed all background processes"

From the above image, you can see that all the background processes have been executed successfully.

6. Trapping and Executing Cleaning-up Actions

In Bash, the trap command is used to handle signals received by the script. It ensures proper clean-up of the background processes when receiving particular signals like SIGINT (CTRL + C) or SIGTERM. Often, the combination of trap and the “wait” command can be useful for handling signals and controlling background processes.

Go through the script below to handle interruptions gracefully in Bash:

#!/bin/bash

#Starting a process in the background
sleep 10 &

#Storing the PID of the process
pid=$!

#Trapping SIGINT signal and killing the background process
trap "kill $pid" SIGINT

echo "Running background process"

#Waiting for the background process to finish
wait $pid

echo "Completed the process"

From the image, you can see that when I have pressed CTRL + C to send the SIGINT signal, the trap catches it and terminates the background process displaying a message of indication ‘Completed the process’. In this case, the “wait” command won’t wait for the background process to complete.

Conclusion

To sum up, the “wait” command is a powerful and easy-to-use command for managing background processes in Bash scripts. Mastering this command increases reliability, synchronizes processes, and simplifies workflow management during Bash scripting.

People Also Ask

What does the wait command do?

The wait command pauses the execution of a Bash script until all background processes within the script are completely executed. It ensures that the script will not continue until the background processes have finished running. You can use the ‘wait’ command to schedule the execution of the tasks that are running in parallel and make sure that everything is running in the correct order within the script.

Can multiple wait commands be used sequentially?

Yes, multiple ‘wait’ commands can be used sequentially in Bash where each ‘wait’ command using the PIDs waits for the corresponding background processes to finish by employing syntaxes like wait $PID1, wait &PID2, wait $PID3.

How do you wait 10 seconds in Linux shell?

To wait for 10 seconds in Linux shell, you can use the sleep command with an ampersand & at the end. For example:

#!/bin/bash

#Starting a background process that sleeps for 10 seconds
sleep 10 &

#Waiting for the background process to finish
wait

echo "Waiting for 10 seconds completed."

Is the wait command suitable for handling asynchronous operations in Bash?

Yes, the ‘wait’ command is suitable for handling asynchronous operations in Bash because it provides flexibility in waiting for specific processes, synchronizes script executions, and provides efficient error handling which is very crucial for process management.

How do you specify which background processes to wait for with the wait command?

To specify which background processes to wait for, you can use the PIDs of the processes as arguments to the ‘wait’ command. For example:

#!/bin/bash

#Launching a background process
sleep 4 &
pid1=$!  #Storing the PID

#Launching another background process
sleep 2 &
pid2=$!  #Storing the PID

#Waiting for the specified background processes to complete
wait $pid1 $pid2

echo "All processes completed."

Related Articles

• How to Add Delays in Bash? [Sleep for a Time]
• How to Measure Bash Elapsed Time? [Seconds to Milliseconds]
• How to Shutdown Linux? [Fixed “Shutdown Command Not Found”]

---

<< Go Back to Process Management in Bash | Bash Process and Signal Handling | Bash Scripting Tutorial