Bash wait Command in Linux with 4 Examples

bash wait command

Many scripts rely on the outcome of external utilities and processes to process and achieve their objectives. 

This external dependency means that the script execution needs a mechanism that allows for monitoring process termination. This mechanism should “freeze” script execution until it receives a signal about the successful or otherwise outcome of the specified processes. 

Bash provides the wait command as this mechanism. In technical terms, the wait command instructs your script to pause and wait for a specific background process to complete. In some instances, this command can be used to wait for all background processes to finish their tasks.

In this tutorial, we will see the wait command in action. We will see four detailed examples of how you can use the wait command to work with one or more processes. 

Table Of Contents

  1. An Overview of the Bash Wait Command
    1. The Basic Syntax of the wait Command in Linux
    2. Understanding Job Specification
  2. 4 Examples of the wait Command in Linux Bash Scripts
    1. The Prerequisites
    2. Example #1: Use wait for a Single Process
    3. Example #2: Use wait for Single Process Synchronization
    4. Example #3: Use wait for Managing Multiple Background Processes
    5. Example #4: Use PID with wait for Managing Multiple Processes
  3. Conclusion
  4. FAQs

An Overview of the Bash Wait Command

Before diving into examples and practical applications, let’s go into the details of the syntax of the wait command. Understanding this syntax is the key to unlocking its full potential.

The Basic Syntax of the wait Command in Linux

The wait command follows a simple structure:

# wait [options] [job_specification]

  • [options]: While wait itself is straightforward, certain implementations of Bash allow options to modify its behavior. However, in its most basic form, which is most widely used, wait does not require any options.
  • [job_specification]: This can be the job ID (when you use job control) or the process ID (PID) of the specific background process you’re waiting for. If you don’t specify a job or process, wait will pause the execution of the script until all background jobs have completed.

Understanding Job Specification

When specifying a job in the wait command, you’re telling the system which background process or processes to wait for. This can be:

  • A single process ID (PID). In this case, the wait command would wait for that specific process to complete.
  • Multiple PIDs. In this case, the wait command would wait for all specified processes to finish.
  • Omit the PID. In this case, the script waits for all background processes to conclude.

This syntax is very versatile, offering a robust mechanism for synchronizing the execution of scripts with the lifecycle of processes. 

Whether you’re writing scripts that initiate and manage background tasks or orchestrating complex workflows that depend on the completion of previous steps, understanding and using the wait command can transform your approach to bash scripting.

Also Read: lsof Command in Linux with Examples

4 Examples of the wait Command in Linux Bash Scripts

Let’s look at four examples where the wait command plays a central role in script execution. 

The Prerequisites

Before discussing the details of the sample scripts, it is important to have the following:

  • A Basic Understanding of Bash: Familiarity with Bash scripting and command-line operations is essential. This foundation will help you grasp the concepts discussed in the sample scripts with ease.
  • Access to a Linux or Unix-like System: We suggest trying out these examples on a system running any mainstream Linux distributions. 

Example #1: Use wait for a Single Process

Let’s start with a basic example where we will use the wait command to pause the execution of a script until a specific background process concludes. 

Consider the scenario where you have initiated a process in the background and wish to hold the script’s progression until this process is complete. This sample script outlines one approach to implementing this scenario:

#!/bin/bash

# Starting a background process

sleep 30 &

# Process ID of the last background process

PID=$!

echo "Waiting for the sleep command to complete."

# Wait command in action

wait $PID

echo "Process completed. Continuing with the script."

In this sample script, we’ve used the sleep command to simulate a background process that takes 30 seconds to complete. The script waits for this process to finish before moving on to the next command (the final echo statement).

nano wait1.sh

Example #2: Use wait for Single Process Synchronization

In this example, we will expand on the previous example and explore how you can apply the wait command in a more complex script context:

#!/bin/bash

# Executing a custom script in the background

./my_custom_script.sh &

# Capturing the PID

PID=$!

echo "my_custom_script.sh is running in the background. PID: $PID"

# Waiting for the specific process to finish

wait $PID

echo "my_custom_script.sh has completed its execution."

Here, the script executes my_custom_script.sh in the background and uses wait to pause script execution until my_custom_script.sh finishes. This example underscores the wait command’s utility in managing dependencies between scripts and processes.

nano wait2.sh

Example #3: Use wait for Managing Multiple Background Processes

You will realize the complete potential of the wait command when working with multiple background processes. 

Consider the following example script where we would use the flexibility of the wait command to wait for multiple processes to complete before proceeding with script execution:

#!/bin/bash

# Starting multiple background processes

sleep 10 &

PID1=$!

sleep 20 &

PID2=$!

sleep 30 &

PID3=$!

echo "Waiting for all background processes to complete."

# Waiting for all specified processes to finish

wait $PID1 $PID2 $PID3

echo "All processes have completed."

This script initiates three background processes with different durations (sleep 10, sleep 20, and sleep 30). By specifying each PID with the wait command, the script pauses until all three processes conclude, demonstrating the command’s efficacy in synchronizing complex workflows.

nano wait3.sh

Example #4: Use PID with wait for Managing Multiple Processes

For a deeper dive into process management with the wait command, consider the scenario where you need precise control over multiple specific background processes. For this, we recommend the following sample script, where we adapted the wait command to ensure each process is completed before moving forward:

#!/bin/bash

# Starting several background processes

./long_running_process.sh &

PID1=$!

./resource_intensive_process.sh &

PID2=$!

echo "Processes are running in the background."

# Waiting for the first process to complete

wait $PID1

echo "First process completed."

# Proceeding after the first process has finished

# Now, waiting for the second process

wait $PID2

echo "Second process completed. Script can now continue with subsequent tasks."

During the execution, the script manages two distinct processes (long_running_process.sh and resource_intensive_process.sh), waiting for each to complete in sequence. This showcases the wait command’s capability to handle complex dependencies and build script-based command pipelines with granular precision.

nano wait4.sh

Conclusion

The wait command is a fundamental yet powerful component of bash scripting, enabling precise control over the execution flow of scripts in relation to background processes. By understanding and utilizing wait, you can create more efficient, reliable, and manageable bash scripts.

As we’ve seen through various examples, whether you’re handling a single process or managing multiple tasks, the wait command can significantly enhance your scripting capabilities. Remember, practice is key to mastering its application.

Understanding process control is equally vital for users. Incorporating bash scripting skills, including the use of the wait command, can significantly contribute to the effective management of server resources, paving the way for smoother, more reliable hosting experiences.

So, If you’re looking for a robust server for your Linux projects, we offer the best dedicated server pricing and deliver instant dedicated servers, usually on the same day the order gets approved. Whether you need a dedicated server, a traffic-friendly 10Gbps dedicated server, or a powerful bare metal server, we are your trusted hosting partner.

FAQs

Q. What is the Bash wait command?

The Bash wait command is a shell command that waits for a specific process or job to finish before executing the next command.

Q. How does the wait command work in Linux?

The wait command in Linux waits for the exit status of the last child processes and returns the exit status once the specified process or job has completed.

Q. How can I use the wait command in my Bash script?

You can use the wait command by specifying the job or process you want to wait for after the command. For example, “wait %1” will wait for the first job.

Q. Can you provide an example of using the wait command?

Sure! If you have multiple processes running in the background and you want to wait for the first job to finish before proceeding, you can use “wait %1” in your script.

Q. What is the significance of the exit status in relation to the wait command?

The wait command returns the exit status of the last process or job that was waited for. This can be useful for error handling or termination of specific tasks.

Q. Is the wait command a built-in command in Bash?

Yes, the wait command is a built-in command in the Bash shell. It is a powerful tool that allows you to control the flow of your scripts based on the completion of specific processes.

Q. How can I use the wait command effectively with examples?

You can utilize the wait command in scenarios where you want to ensure that a certain process or job has completed before proceeding with the next set of commands. For example, in a script where you need to wait for the completion of a background task before moving on to the next step.