Retraso de ejecución en Linux

Introducción

En este laboratorio, aprenderá cómo utilizar el comando sleep en Linux, que le permite introducir pausas o retrasos temporizados en sus scripts y secuencias de comandos. La capacidad de controlar el tiempo es esencial para muchas tareas de scripting, como crear períodos de espera entre operaciones, simular interacciones de usuario o controlar el flujo de ejecución de un script.

Al final de este laboratorio, entenderá cómo utilizar el comando sleep tanto con valores fijos como con variables para crear controles de tiempo flexibles en sus scripts de shell de Linux.

Skills Graph

Comprendiendo el comando Sleep

El comando sleep en Linux es una utilidad simple pero poderosa que pausa la ejecución de un script o secuencia de comandos durante una cantidad de tiempo especificada. Esto es especialmente útil en scripts de shell cuando se necesita crear retrasos entre comandos.

Comencemos explorando el uso básico del comando sleep.

Primero, navegue hasta el directorio de su proyecto:

cd ~/project

Ahora, intentemos usar el comando sleep directamente en la terminal. Escriba el siguiente comando:

echo "Start time: $(date +%H:%M:%S)"
sleep 3
echo "End time: $(date +%H:%M:%S)"

Cuando ejecute esta secuencia de comandos, verá impresa la hora de inicio, seguida de una pausa de 3 segundos y luego la hora de finalización. La salida se verá similar a esto:

Start time: 10:15:30
End time: 10:15:33

La sintaxis básica del comando sleep es:

sleep NUMBER[SUFFIX]

Donde:

• NUMBER es la cantidad de tiempo para dormir (pausar la ejecución)
• SUFFIX es opcional y puede ser:
  • s para segundos (valor predeterminado si no se especifica ningún sufijo)
  • m para minutos
  • h para horas
  • d para días

Intentemos algunos ejemplos para ver cómo funcionan las diferentes unidades de tiempo:

## Sleep for 5 seconds
echo "Sleeping for 5 seconds..."
sleep 5
echo "Done!"

## Sleep for 0.5 seconds (half a second)
echo "Sleeping for half a second..."
sleep 0.5
echo "Done!"

Ahora entiende cómo funciona el comando sleep a un nivel básico. En el siguiente paso, lo incorporaremos a un script de shell.

Creando un script de shell básico con Sleep

Ahora que entiende cómo funciona el comando sleep, creemos un script de shell que lo utilice. Los scripts de shell le permiten automatizar secuencias de comandos y son una herramienta fundamental en la administración de Linux.

Primero, creemos un nuevo archivo de script de shell en el directorio de su proyecto:

cd ~/project
touch delay_script.sh

A continuación, abra el archivo utilizando el editor de texto nano:

nano delay_script.sh

Agregue el siguiente contenido al archivo:

#!/bin/zsh

echo "Starting the script..."
echo "First message appears immediately."
sleep 2
echo "Second message appears after 2 seconds."
sleep 3
echo "Third message appears after 3 more seconds."
echo "Script execution complete."

Para guardar el archivo en nano, presione Ctrl+O, luego presione Enter para confirmar y, finalmente, presione Ctrl+X para salir del editor.

Antes de poder ejecutar el script, debemos hacer que sea ejecutable:

chmod +x delay_script.sh

Ahora, ejecutemos el script:

./delay_script.sh

Debería ver que los mensajes aparecen con los retrasos especificados:

Starting the script...
First message appears immediately.
Second message appears after 2 seconds.
Third message appears after 3 more seconds.
Script execution complete.

Este simple script demuestra cómo se puede utilizar el comando sleep para controlar el tiempo en que se muestran los mensajes. Esta técnica es útil en muchos escenarios de scripting, como:

1. Simular interacciones de usuario
2. Esperar a que un proceso se complete
3. Crear indicadores de progreso
4. Limitar la tasa de operaciones

Examinemos lo que hace el script línea por línea:

1. #!/bin/zsh - Esto se llama línea shebang, que especifica que el script debe ejecutarse utilizando la shell zsh.
2. echo "Starting the script..." - Imprime el mensaje inicial.
3. echo "First message appears immediately." - Imprime el primer mensaje inmediatamente.
4. sleep 2 - Pausa la ejecución del script durante 2 segundos.
5. echo "Second message appears after 2 seconds." - Imprime el segundo mensaje después del retraso de 2 segundos.
6. sleep 3 - Pausa la ejecución del script durante 3 segundos adicionales.
7. echo "Third message appears after 3 more seconds." - Imprime el tercer mensaje después del retraso de 3 segundos.
8. echo "Script execution complete." - Imprime el mensaje final.

En el siguiente paso, exploraremos cómo hacer que las duraciones de las pausas (sleep) sean más flexibles utilizando variables.

Usando variables con el comando Sleep

En los scripts del mundo real, a menudo se necesita más flexibilidad que las duraciones de pausa (sleep) codificadas de forma rígida. Utilizar variables para los tiempos de pausa hace que tus scripts sean más adaptables y fáciles de mantener. Creemos un nuevo script que demuestre este concepto.

Primero, crea un nuevo archivo:

cd ~/project
touch variable_delay.sh

Abre el archivo con nano:

nano variable_delay.sh

Agrega el siguiente contenido:

#!/bin/zsh

## Define delay durations as variables
SHORT_DELAY=1
MEDIUM_DELAY=3
LONG_DELAY=5

echo "Starting the script with variable delays..."

echo "This is displayed immediately."
echo "Waiting for a short delay (${SHORT_DELAY} seconds)..."
sleep $SHORT_DELAY
echo "Short delay completed."

echo "Waiting for a medium delay (${MEDIUM_DELAY} seconds)..."
sleep $MEDIUM_DELAY
echo "Medium delay completed."

echo "Waiting for a long delay (${LONG_DELAY} seconds)..."
sleep $LONG_DELAY
echo "Long delay completed."

echo "Script execution complete."

Guarda y sal de nano usando Ctrl+O, Enter y Ctrl+X.

Haz el script ejecutable:

chmod +x variable_delay.sh

Ahora ejecuta el script:

./variable_delay.sh

La salida será similar a:

Starting the script with variable delays...
This is displayed immediately.
Waiting for a short delay (1 seconds)...
Short delay completed.
Waiting for a medium delay (3 seconds)...
Medium delay completed.
Waiting for a long delay (5 seconds)...
Long delay completed.
Script execution complete.

Entendamos por qué usar variables para los tiempos de pausa es beneficioso:

1. Legibilidad: Usar nombres de variables descriptivos como SHORT_DELAY hace que el código sea autodocumentado.
2. Mantenibilidad: Si necesitas cambiar un tiempo de pausa, solo necesitas modificarlo en un lugar (la declaración de la variable) en lugar de en todo el script.
3. Consistencia: Si la misma duración de pausa se utiliza varias veces, usar una variable asegura que todas las instancias usen el mismo valor.
4. Flexibilidad: Puedes cambiar fácilmente los tiempos de pausa modificando solo los valores de las variables.

También puedes realizar cálculos con estas variables. Creemos un script más para demostrarlo:

cd ~/project
touch calculated_delay.sh
nano calculated_delay.sh

Agrega el siguiente contenido:

#!/bin/zsh

## Base delay time in seconds
BASE_DELAY=2

echo "Starting script with calculated delays..."

## Using the base delay
echo "Waiting for the base delay (${BASE_DELAY} seconds)..."
sleep $BASE_DELAY
echo "Base delay completed."

## Double the base delay
DOUBLE_DELAY=$((BASE_DELAY * 2))
echo "Waiting for double the base delay (${DOUBLE_DELAY} seconds)..."
sleep $DOUBLE_DELAY
echo "Double delay completed."

## Half the base delay
HALF_DELAY=$(echo "scale=1; $BASE_DELAY / 2" | bc)
echo "Waiting for half the base delay (${HALF_DELAY} seconds)..."
sleep $HALF_DELAY
echo "Half delay completed."

echo "Script execution complete."

Guarda, sal de nano y haz el script ejecutable:

chmod +x calculated_delay.sh

Ejecuta el script:

./calculated_delay.sh

La salida será similar a:

Starting script with calculated delays...
Waiting for the base delay (2 seconds)...
Base delay completed.
Waiting for double the base delay (4 seconds)...
Double delay completed.
Waiting for half the base delay (1.0 seconds)...
Half delay completed.
Script execution complete.

Esto demuestra cómo se pueden calcular dinámicamente los tiempos de pausa basados en un solo valor base, lo que hace que tus scripts sean aún más flexibles y poderosos.

Aplicaciones prácticas del comando Sleep

Ahora que entiendes los conceptos básicos del comando sleep y cómo usarlo con variables, exploremos algunas aplicaciones prácticas. Estos ejemplos demuestran cómo se utiliza el comando sleep en escenarios del mundo real.

Creando un sencillo temporizador de cuenta regresiva

Creemos un temporizador de cuenta regresiva que demuestre un uso más complejo del comando sleep:

cd ~/project
touch countdown.sh
nano countdown.sh

Agrega el siguiente contenido:

#!/bin/zsh

## Function to display a countdown
countdown() {
  local seconds=$1
  while [ $seconds -gt 0 ]; do
    echo -ne "\rTime remaining: $seconds seconds "
    sleep 1
    ((seconds--))
  done
  echo -e "\rCountdown complete!            "
}

## Specify the countdown duration
echo "Starting a 5-second countdown:"
countdown 5
echo "Countdown script execution complete."

Guarda, sal de nano y haz el script ejecutable:

chmod +x countdown.sh

Ejecuta el script:

./countdown.sh

Deberías ver una cuenta regresiva desde 5 segundos hasta 0, con la actualización del tiempo en el mismo lugar:

Starting a 5-second countdown:
Time remaining: 5 seconds
Time remaining: 4 seconds
Time remaining: 3 seconds
Time remaining: 2 seconds
Time remaining: 1 seconds
Countdown complete!
Countdown script execution complete.

Simulando un proceso con indicador de progreso

Creemos un script que simule un proceso de larga duración con un sencillo indicador de progreso:

cd ~/project
touch progress.sh
nano progress.sh

Agrega el siguiente contenido:

#!/bin/zsh

## Function to show a simple progress bar
show_progress() {
  local duration=$1
  local steps=10
  local step_duration=$(echo "scale=2; $duration / $steps" | bc)

  echo "Starting process..."
  echo -n "Progress: ["
  for i in {1..10}; do
    sleep $step_duration
    echo -n "#"
  done
  echo "] Done!"
}

## Run a process that takes 5 seconds with a progress indicator
show_progress 5
echo "Process completed successfully."

Guarda, sal de nano y haz el script ejecutable:

chmod +x progress.sh

Ejecuta el script:

./progress.sh

Deberías ver una barra de progreso que se llena en 5 segundos:

Starting process...
Progress: [##########] Done!
Process completed successfully.

Controlando la tasa de operaciones

En este ejemplo, demostraremos cómo usar el comando sleep para controlar la tasa de operaciones, lo cual es útil para limitar la tasa de llamadas a una API o procesar grandes conjuntos de datos:

cd ~/project
touch rate_limit.sh
nano rate_limit.sh

Agrega el siguiente contenido:

#!/bin/zsh

## Define the rate limit (operations per second)
OPERATIONS_PER_SECOND=2
SLEEP_DURATION=$(echo "scale=3; 1 / $OPERATIONS_PER_SECOND" | bc)

echo "Performing operations at a rate of $OPERATIONS_PER_SECOND per second"
echo "Each operation will be followed by a $SLEEP_DURATION second delay"

## Simulate 6 operations with rate limiting
for i in {1..6}; do
  echo "Performing operation $i at $(date +%H:%M:%S.%N | cut -c1-12)"
  ## Simulate the operation
  sleep 0.1
  ## Rate-limiting delay between operations
  if [ $i -lt 6 ]; then
    sleep $SLEEP_DURATION
  fi
done

echo "All operations completed"

Guarda, sal de nano y haz el script ejecutable:

chmod +x rate_limit.sh

Ejecuta el script:

./rate_limit.sh

Deberías ver que las operaciones se realizan a una tasa controlada:

Performing operations at a rate of 2 per second
Each operation will be followed by a 0.500 second delay
Performing operation 1 at 10:30:45.12
Performing operation 2 at 10:30:45.72
Performing operation 3 at 10:30:46.32
Performing operation 4 at 10:30:46.92
Performing operation 5 at 10:30:47.52
Performing operation 6 at 10:30:48.12
All operations completed

Estos ejemplos demuestran cómo se puede usar el comando sleep en escenarios de scripting más avanzados. La capacidad de controlar el tiempo es una herramienta poderosa en el scripting de shell que permite muchas aplicaciones prácticas.

Resumen

En este laboratorio, has aprendido cómo usar el comando sleep en Linux para introducir retrasos temporizados en tus scripts de shell. Esta es una habilidad fundamental para la escritura de scripts y las operaciones de línea de comandos que requieren un control preciso del tiempo.

Conceptos clave cubiertos en este laboratorio:

1. Uso básico del comando sleep con diferentes unidades de tiempo (segundos, minutos, horas)
2. Creación de scripts de shell que incorporen el comando sleep
3. Uso de variables para hacer las duraciones de pausa más flexibles y fáciles de mantener
4. Realización de cálculos con variables de duración de pausa
5. Aplicaciones prácticas del comando sleep:
   • Creación de temporizadores de cuenta regresiva
   • Implementación de indicadores de progreso
   • Control de la tasa de operaciones

Estas habilidades serán valiosas en muchos escenarios de scripting de Linux, incluyendo:

• Automatización de tareas que requieran un tiempo específico
• Creación de interfaces amigables para el usuario con pausas adecuadas
• Implementación de limitación de tasa para llamadas a API o operaciones intensivas en recursos
• Simulación de interacciones de usuario
• Gestión del flujo de ejecución de scripts

Al dominar el comando sleep, ahora tienes una herramienta importante en tu kit de herramientas de scripting de Linux que te ayudará a crear scripts más sofisticados y amigables para el usuario.