usleep

Delay in microseconds

$ usleep [microseconds]

$ usleep 500000 && [command]

usleep microseconds

microseconds
    The positive integer representing the number of microseconds for which the process should suspend execution.

The `usleep` "command" (more commonly a C library function) is used to suspend the execution of the calling process or thread for a specified number of microseconds. Its primary purpose is to introduce short, precise delays in programs or scripts, enabling fine-grained control over timing, which is particularly useful for tasks like polling hardware, debouncing inputs, or synchronizing operations that require brief pauses. While it aims for microsecond granularity, the actual sleep duration might be longer due to system scheduling latency and kernel tick rates. For shell scripting, it's less common as a direct standalone utility compared to `sleep(1)`, which operates on seconds, but it might be available in minimal environments like BusyBox. In modern C/C++ programming, it has largely been superseded by `nanosleep()` for higher precision and better signal handling characteristics.

Deprecation: The `usleep()` function is officially deprecated in POSIX.1-2008. It is recommended to use `nanosleep(2)` instead for new code, as `nanosleep` provides better control over signal handling and nanosecond precision.

Precision and Granularity: Although `usleep` aims for microsecond precision, the actual duration of the sleep is subject to the system's clock resolution and scheduler latency. The process might sleep for longer than the requested duration, especially on busy systems or systems with coarse timer interrupts.

Command Availability: It is crucial to note that `usleep` is primarily a C library function (`usleep(3)`). It is not a standard standalone shell command on most mainstream Linux distributions. If encountered as a command, it's typically provided by utility collections like BusyBox, as a shell built-in in specific environments, or as part of a custom script wrapper.

Interruptibility: Like other sleep functions, `usleep` can be interrupted by signals. Upon interruption, it typically returns early.

When used as a C library function, `usleep()` typically returns 0 on success. If an error occurs (e.g., an invalid argument), it returns -1. If the sleep is interrupted by a signal, it returns early.

To pause execution for 100 milliseconds (100,000 microseconds), if `usleep` were available as a shell command, one would use:

usleep 100000

However, in modern shell scripting, it's generally recommended to use sleep 0.1 for fractional second pauses.

The `usleep` function has been a part of Unix-like systems for a long time, providing a simple way to introduce pauses with microsecond granularity. It was a common utility in early POSIX standards. However, with the evolution of system requirements for higher precision timing and more robust signal handling, `usleep()` was marked as deprecated in the POSIX.1-2008 standard. Its role has largely been taken over by the `nanosleep()` system call, which offers finer (nanosecond) control and more predictable behavior when signals are involved. Despite its deprecation, `usleep` remains widely supported by C libraries for backward compatibility and is still frequently encountered in existing codebases and simple scripting scenarios where its characteristics are sufficient.

sleep(1), nanosleep(2), wait(1)