Espera de procesos en Linux

Introducción

Los procesos de Linux son componentes fundamentales del sistema operativo que ejecutan programas y realizan tareas. Al desarrollar scripts de shell, a menudo es necesario ejecutar múltiples procesos de forma concurrente y asegurarse de que se completen antes de continuar con las operaciones posteriores.

En este laboratorio, aprenderá sobre el comando wait en la programación de scripts de shell de Linux. Esta poderosa herramienta permite a los procesos padre pausar la ejecución hasta que sus procesos hijos en segundo plano hayan finalizado. Al dominar las técnicas de espera de procesos, puede crear scripts más eficientes que coordinen adecuadamente múltiples operaciones concurrentes.

Comprender la espera de procesos es esencial para la administración del sistema, la automatización y el desarrollo de scripts de shell robustos. Aprenderá cómo iniciar procesos en segundo plano, esperar a que se completen y manejar sus estados de salida para garantizar un flujo de ejecución confiable.

Comprender los procesos de Linux y la ejecución en segundo plano

En este paso, aprenderá sobre los procesos de Linux y cómo ejecutar comandos en segundo plano utilizando el operador &.

¿Qué son los procesos de Linux?

Un proceso en Linux es una instancia de un programa en ejecución. Cada proceso tiene un Identificador de Proceso (PID, por sus siglas en inglés) único y se ejecuta de forma independiente de otros procesos. Cuando ejecuta un comando en la terminal, inicia un proceso.

Ejecutar procesos en segundo plano

Normalmente, cuando ejecuta un comando en la terminal, debe esperar a que se complete antes de poder ejecutar otro comando. Sin embargo, puede ejecutar un comando en segundo plano agregando un ampersand & al final del comando.

Vamos a probar esto:

Navegue hasta el directorio de su proyecto:
```
cd ~/project
```
Cree un script simple que simule una tarea de larga duración:
```
nano long_task.sh
```

Agregue el siguiente contenido al script:

#!/bin/bash
echo "Starting long task with PID $$"
sleep 5
echo "Long task completed"

Guarde el archivo presionando Ctrl+O, luego Enter, y salga con Ctrl+X.
Haga el script ejecutable:
```
chmod +x long_task.sh
```
Ejecute el script normalmente:
```
./long_task.sh
```
Verá una salida como esta:
```
Starting long task with PID 1234
Long task completed
```
Note que tuvo que esperar a que el script se completara antes de recuperar el indicador de comando.
Ahora ejecute el script en segundo plano:
```
./long_task.sh &
```
Verá una salida como esta:
```
[1] 1235
Starting long task with PID 1235
```
El [1] es el número de tarea, y 1235 es el PID. Note que recupera el indicador de comando inmediatamente.
Después de aproximadamente 5 segundos, verá:
```
Long task completed
[1]+  Done                    ./long_task.sh
```
Esto indica que el proceso en segundo plano se ha completado.

Cuando ejecuta un comando en segundo plano, la shell no espera a que se complete antes de permitirle ingresar más comandos. Esto es útil para ejecutar múltiples tareas de forma concurrente.

Usando el comando wait para sincronizar procesos

En este paso, aprenderá cómo utilizar el comando wait para sincronizar procesos, lo que hace que el proceso padre espere a que se completen los procesos en segundo plano.

¿Qué es el comando wait?

El comando wait se utiliza en scripts de shell para pausar la ejecución del script hasta que se hayan completado uno o más procesos en segundo plano. Esto es especialmente útil cuando es necesario asegurarse de que ciertas tareas finalicen antes de continuar con las operaciones posteriores.

Uso de wait sin argumentos

Cuando se utiliza sin argumentos, el comando wait espera a que se completen todos los procesos en segundo plano.

Vamos a crear un script que demuestre esto:

Navegue hasta el directorio de su proyecto:
```
cd ~/project
```
Cree un nuevo script:
```
nano wait_demo.sh
```

Agregue el siguiente contenido al script:

#!/bin/bash

echo "Starting background tasks..."

## Start two background tasks
./long_task.sh &
./long_task.sh &

echo "Waiting for all background tasks to complete..."
wait
echo "All background tasks have completed!"

Guarde y salga del editor presionando Ctrl+O, luego Enter y, finalmente, Ctrl+X.
Haga el script ejecutable:
```
chmod +x wait_demo.sh
```

Ejecute el script:

./wait_demo.sh

Verá una salida similar a la siguiente:

Starting background tasks...
Starting long task with PID 1236
Starting long task with PID 1237
Waiting for all background tasks to complete...
Long task completed
Long task completed
All background tasks have completed!

Note que el mensaje "All background tasks have completed!" solo aparece después de que ambas tareas largas hayan finalizado. Esto demuestra cómo el comando wait pausa el script hasta que se completen todos los procesos en segundo plano.

Uso de wait con un PID específico

También puede utilizar wait para esperar a un proceso específico proporcionando su PID:

Cree otro script:
```
nano wait_pid_demo.sh
```

Agregue el siguiente contenido:

#!/bin/bash

echo "Starting background tasks..."

## Start two background tasks and capture their PIDs
./long_task.sh &
pid1=$!

./long_task.sh &
pid2=$!

echo "First process PID: $pid1"
echo "Second process PID: $pid2"

echo "Waiting for the first task to complete..."
wait $pid1
echo "First task has completed!"

echo "Waiting for the second task to complete..."
wait $pid2
echo "Second task has completed!"

Guarde y salga del editor presionando Ctrl+O, luego Enter y, finalmente, Ctrl+X.
Haga el script ejecutable:
```
chmod +x wait_pid_demo.sh
```
Ejecute el script:
```
./wait_pid_demo.sh
```
La salida mostrará que el script espera a cada proceso individualmente.

La variable $! contiene el PID del proceso en segundo plano ejecutado más recientemente. Esto le permite capturar y utilizar posteriormente el PID con el comando wait.

Manejo del estado de retorno de wait

En este paso, aprenderá cómo capturar y manejar el estado de retorno del comando wait, que refleja el estado de salida de los procesos en segundo plano.

Comprender el estado de salida y de retorno

En Linux, cada comando devuelve un estado de salida cuando se completa. Un estado de salida de 0 generalmente indica éxito, mientras que un valor distinto de cero indica un error o algún tipo de fallo.

El comando wait devuelve el estado de salida del comando esperado. Si se esperan varios procesos, devuelve el estado de salida del último proceso que terminó.

Vamos a crear scripts para demostrar esto:

Navegue hasta el directorio de su proyecto:
```
cd ~/project
```
Cree un script que tenga éxito:
```
nano success_task.sh
```

Agregue el siguiente contenido:

#!/bin/bash
echo "Starting success task"
sleep 2
echo "Success task completed successfully"
exit 0 ## Exit with success status

Guarde y salga presionando Ctrl+O, luego Enter y, finalmente, Ctrl+X. Luego, haga que sea ejecutable:
```
chmod +x success_task.sh
```
Cree un script que falle:
```
nano fail_task.sh
```

Agregue el siguiente contenido:

#!/bin/bash
echo "Starting fail task"
sleep 3
echo "Fail task encountered an error"
exit 1 ## Exit with error status

Guarde y salga presionando Ctrl+O, luego Enter y, finalmente, Ctrl+X. Luego, haga que sea ejecutable:
```
chmod +x fail_task.sh
```
Ahora, cree un script que capture el estado de espera:
```
nano wait_status_demo.sh
```

Agregue el siguiente contenido:

#!/bin/bash

echo "Running a successful background task..."
./success_task.sh &
wait

wait_status=$?
echo "Wait returned with status: $wait_status"

if [ $wait_status -eq 0 ]; then
  echo "The background task succeeded!"
else
  echo "The background task failed with status: $wait_status"
fi

echo ""
echo "Running a failing background task..."
./fail_task.sh &
wait

wait_status=$?
echo "Wait returned with status: $wait_status"

if [ $wait_status -eq 0 ]; then
  echo "The background task succeeded!"
else
  echo "The background task failed with status: $wait_status"
fi

Guarde y salga presionando Ctrl+O, luego Enter y, finalmente, Ctrl+X. Luego, haga que sea ejecutable:
```
chmod +x wait_status_demo.sh
```

Ejecute el script:

./wait_status_demo.sh

Verá una salida similar a la siguiente:

Running a successful background task...
Starting success task
Success task completed successfully
Wait returned with status: 0
The background task succeeded!

Running a failing background task...
Starting fail task
Fail task encountered an error
Wait returned with status: 1
The background task failed with status: 1

Esto demuestra cómo se puede utilizar el estado de retorno del comando wait para determinar si los procesos en segundo plano se completaron correctamente o no, lo cual es esencial para el manejo de errores en scripts de shell.

Completar una aplicación práctica

En este último paso, aplicará lo que ha aprendido para crear un script más complejo que simule un proceso de preparación del sistema. Este script coordinará múltiples tareas en segundo plano y se asegurará de que todas se completen correctamente antes de continuar.

Crear los scripts de preparación

Primero, crearemos dos scripts que simulen diferentes tareas de preparación:

Navegue hasta el directorio de su proyecto:
```
cd ~/project
```
Cree el primer script de preparación:
```
nano decorate_hall.sh
```

Agregue el siguiente contenido:

#!/bin/bash
echo "Decorating the hall..."
sleep 3
echo "Hanging decorations..."
sleep 2
echo "Decoration complete."
exit 0

Guarde y salga presionando Ctrl+O, luego Enter y, finalmente, Ctrl+X. Luego, haga que sea ejecutable:
```
chmod +x decorate_hall.sh
```
Cree el segundo script de preparación:
```
nano cook_feast.sh
```

Agregue el siguiente contenido:

#!/bin/bash
echo "Preparing ingredients..."
sleep 2
echo "Cooking main dishes..."
sleep 3
echo "Preparing desserts..."
sleep 1
echo "Cooking complete."
exit 0

Guarde y salga presionando Ctrl+O, luego Enter y, finalmente, Ctrl+X. Luego, haga que sea ejecutable:
```
chmod +x cook_feast.sh
```

Crear el script principal de coordinación

Ahora, creemos el script principal que coordinará estas tareas de preparación:

Cree el script principal:
```
nano prepare_feast.sh
```

Agregue el siguiente contenido:

#!/bin/bash

echo "=== Preparation Ceremony Started ==="
echo "Starting all preparation tasks..."

## Start the preparations in the background
./decorate_hall.sh &
decoration_pid=$!

./cook_feast.sh &
cooking_pid=$!

echo "All tasks started. Waiting for completion..."

## Wait for decoration to finish
wait $decoration_pid
decoration_status=$?

if [ $decoration_status -eq 0 ]; then
  echo "Decoration completed successfully."
else
  echo "Error: Decoration failed with status $decoration_status"
  exit 1
fi

## Wait for cooking to finish
wait $cooking_pid
cooking_status=$?

if [ $cooking_status -eq 0 ]; then
  echo "Cooking completed successfully."
else
  echo "Error: Cooking failed with status $cooking_status"
  exit 1
fi

## All preparations completed successfully
echo "=== All preparations completed successfully! ==="
echo "The ceremony can now begin."

## Create a verification file to indicate successful completion
echo "decoration_status=$decoration_status" > preparation_results.txt
echo "cooking_status=$cooking_status" >> preparation_results.txt
echo "overall_status=0" >> preparation_results.txt

exit 0

Guarde y salga presionando Ctrl+O, luego Enter y, finalmente, Ctrl+X. Luego, haga que sea ejecutable:
```
chmod +x prepare_feast.sh
```
Ejecute el script principal:
```
./prepare_feast.sh
```
Verá la salida de todas las tareas de preparación ejecutándose de forma concurrente, y el script principal esperando a que cada una se complete antes de declarar el éxito general.

Comprender el script

Examinemos las partes clave del script principal:

Iniciamos cada tarea de preparación en segundo plano utilizando &
Capturamos el PID de cada tarea utilizando $!
Esperamos a que cada tarea se complete utilizando wait $pid
Comprobamos el estado de salida de cada tarea
Creamos un archivo de verificación con los resultados

Este enfoque nos permite:

Ejecutar múltiples tareas de forma concurrente
Monitorear el éxito/fallo de cada tarea
Abortar el proceso general si alguna tarea individual falla
Crear un registro de los resultados

Este es un patrón común en la administración de sistemas y los scripts de automatización, donde se deben coordinar y monitorear múltiples procesos.

Resumen

En este laboratorio, ha aprendido cómo administrar y sincronizar procesos de manera efectiva en Linux utilizando el comando wait. Esta habilidad importante le permite crear scripts de shell más sofisticados que pueden coordinar múltiples operaciones concurrentes.

Los conceptos clave que ha dominado incluyen:

Ejecutar procesos en segundo plano utilizando el operador &
Utilizar el comando wait para pausar la ejecución hasta que se completen los procesos en segundo plano
Esperar a procesos específicos por su PID
Capturar y manejar el estado de retorno del comando wait
Implementar manejo de errores para procesos en segundo plano
Coordinar múltiples tareas concurrentes en un escenario práctico

Estas habilidades son fundamentales para la administración de sistemas, la automatización y la escritura de scripts de shell en entornos Linux. Al administrar adecuadamente la sincronización de procesos, puede crear scripts más eficientes que aprovechen la concurrencia mientras mantienen la secuencia adecuada de operaciones dependientes.

Ya sea que esté desarrollando sistemas de compilación, scripts de implementación o herramientas de administración de sistemas, la capacidad de coordinar múltiples procesos es una habilidad esencial que le permitirá crear soluciones más poderosas y eficientes.