usleep Command in Linux

Previous
Quiz
Next

In Unix-like operating systems, controlling timing can be crucial for many tasks. Whether you're writing shell scripts that require a brief pause between commands, synchronizing interactions with hardware, or simply waiting for a resource to become available, you sometimes need to suspend execution for a very short period. The usleep command is especially designed for this purpose, it allows your program or script to pause for a specified number of microseconds.

Table of Contents

Here is a comprehensive guide to the options available with the usleep command −

Understanding Linux usleep Command

Unlike the more commonly known sleep command (which accepts delays in seconds, minutes, hours, or days), usleep grants you a finer degree of control by supporting microsecond granularity.

Originally, the concept of microsecond sleep emerged from its use as a function in the C library (declared in <unistd.h>), where it served to suspend the calling thread for at least a specified number of microseconds.

Although its use has been marked as obsolete by newer standards like POSIX.1-2001 (which suggests nanosleep(2) instead), the utility remains popular in many environments because it is simple, effective, and easy to integrate into legacy or time-sensitive scripting tasks.

The Linux implementation of usleep provides a way to incorporate this high-resolution delay into shell scripts or command-line operations. You can use it to introduce very short pauses (waiting 100,000 microseconds for 0.1 seconds) that are difficult to achieve with the standard sleep command, which, until more recent implementations, accepted only integer seconds.

Historical Context and Purpose of usleep Command

The usleep function was first introduced in older BSD variants and later standardized as a part of POSIX on many Unix systems. Its main purpose was to give developers the ability to suspend execution in units far smaller than a second. When used in the C language, its prototype is −

include <unistd.h>
int usleep(useconds_t usec);

Here, the usec parameter specifies the number of microseconds of suspension. This function is especially useful when microsecond-level delays are needed - for example, in embedded systems programming, real-time data acquisition, or when communicating with peripherals that require very fine timing control.

Basic Usage of usleep Command

When using usleep from the command line (or through a script), the syntax is straightforward −

usleep [OPTION]... NUMBER

Here, NUMBER represents the delay in microseconds. For example −

Use the following option to sleep for 0.5 seconds (500,000 microseconds) −

usleep 500000

Use the following option to sleep for 100 milliseconds (100,000 microseconds) −

usleep 100000

In typical usage, you might not need additional options; you simply provide the numerical value. However, like many Unix commands, usleep supports several command-line arguments that can display help information or version details.

Command-Line Options Used with usleep Command

Even though usleep is a simple tool whose main action is to pause for a given number of microseconds, it does also support a few options. Understanding these options can help you integrate the command more seamlessly into your workflow.

--help or -?

If you ever need a quick reminder of the usage, the --help option will display a short usage message. For example, running −

usleep --help

It will print a help message that outlines the basic application syntax and a brief description of its functionality. This option is especially useful for beginners who want to verify that they are using the command correctly.

--version or -v

The --version option prints version information about the usleep command. For example −

usleep --version

This command outputs the current version of the utility and perhaps some copyright details. For users who wish to know whether they are running the latest version, checking the version can be an important step.

How to Use usleep Command in Linux?

To fully grasp how usleep can be incorporated into your scripts, here are several detailed examples that illustrate its practical applications.

Basic Shell Script Example

Consider a basic shell script that prints messages with a pause in between. This is useful when you want to create a timed display or when interacting with other processes where a slight delay is required.

#!/bin/
echo "Starting process..."
usleep 500000    Sleep for 500,000 microseconds or 0.5 seconds
echo "Half a second has passed."
usleep 250000    Sleep for 250,000 microseconds or 0.25 seconds
echo "An additional quarter second has passed."
echo "Process complete."

In this script, messages are printed with delays of 0.5 seconds and 0.25 seconds between them. The use of usleep here ensures you have fine control over these timing intervals.

Using usleep in a Loop

Sometimes, you need to perform an operation repeatedly with a fine-tuned delay between each iteration. Here's an example using a loop to simulate a periodic task −

#!/bin/
for i in {1..5}; do
	echo "Iteration $i: Performing a task..."
	usleep 200000    200,000 microseconds = 0.2 seconds
done
echo "Finished all iterations."

This loop prints out a message five times, pausing for 0.2 seconds between iterations. Such an approach is particularly useful in real-time logging, monitoring interfaces, or when polling a system resource at high frequency.

Coordinating Multiple Processes

In concurrent or asynchronous scripting, you may need to ensure that one background process has enough time to initialize before another process begins. For example −

#!/bin/
 Start a background process
./start_daemon.sh &
daemon_pid=$!
echo "Daemon started with PID $daemon_pid."

Give the daemon time to start completely
usleep 300000    Sleep for 300,000 microseconds (0.3 seconds)

Now start another process that relies on the daemon being active
./do_task.sh
echo "Task executed after allowing time for daemon startup."

In this script, usleep is used to insert a short pause after launching a daemon process. This delay helps ensure that the daemon has time to initialize before the task that depends on it begins.

Combining with Other Commands

Since usleep is often used as part of shell pipelines, you might see it combined with commands such as date or custom logging functions. For example −

#!/bin/
Print the current time, wait for 100 milliseconds, then print updated time
echo "Current time: $(date)"
usleep 100000    0.1 second delay
echo "Time after 0.1 sec: $(date)"

This simple script shows a rapid change in timestamps, which can be useful for debugging the responsiveness of certain systems or checking if a function call happens within a required time window.

Conclusion

The Linux usleep command is a small but powerful utility that allows you to suspend process execution for microsecond intervals. Its simplicity and precision make it an essential tool in shell scripting, automation, and real-time programming environments.

From printing incremental messages in a loop to synchronizing complex processes and coordinating timed actions between multiple scripts, usleep provides fine-grained control that goes beyond the standard sleep command.

Print Page
Previous
Next
Advertisements