Wait es un comando de shell que espera a que se complete un proceso determinado y luego devuelve su estado de salida. El comando Wait se usa para esperar el ID de proceso y el ID de trabajo en particular y devolver su estado de terminación.
Al ejecutar el gran flujo de automatización, necesitamos hacer que algunos módulos esperen hasta que el conjunto anterior de módulos se complete y devuelva los datos canalizados a los siguientes módulos, en este caso podemos usar el comando Esperar hasta completar el módulo anterior.
Cómo funciona el comando de espera
El comando Wait utilizado para monitorear el proceso anterior, depende del estado de retorno del proceso anterior, devolverá el estado de salida. Para example, si queremos esperar para completar un ID de proceso en particular 13245, entonces debemos usar “esperar 13245” cuando el proceso 13245 complete el comando de espera devuelva los valores de retorno del estado de salida 13245.
– PID de espera (PID – ID de proceso de un comando, para el cual la utilidad debe esperar la terminación).
– Wait JID (JID – ID de trabajo que identifica un proceso en segundo plano para esperar, aplicable solo para invocaciones de espera en el entorno de ejecución de shell actual).
El valor de estado de salida del comando de espera depende del último PID / JID especificado. Cuando cualquier proceso finaliza de forma anormal, el estado de salida será superior a 128.
El comando Wait sale con el valor 0 cuando llama sin un proceso hijo y todos los ID de proceso son conocidos por el shell actual han terminado. Si el comando de espera detecta algún error, devuelve cualquier valor de 1 a 126. Si se desconoce el último ID de proceso, el comando de espera sale con el valor 127.
Ejemplos de comandos de espera
Revisemos algunos scripts para comprender cómo funciona el comando de espera.
Ejemplo 1 – Script con comando Wait
Tenemos dos secuencias de comandos llamadas ‘foo.sh’ y secuencia de comandos ‘bar.sh’. El script ‘Foo.sh’ imprime números entre 1 y 5 y el script ‘bar.sh’ llamará al foo.sh y lo ejecutará en segundo plano, obtendrá el PID de foo.sh y esperará a que se complete, una vez completado, lo hará iniciar el bucle ‘bar.sh’ y completar.
Secuencia de comandos – foo.sh
#!/bin/bash
for i in 1 2 3 4 5
do
echo “foo.sh – Looping … number $i”
done
Secuencia de comandos – bar.sh
#!/bin/bash
echo “Started bar.sh”
echo “Started foo.sh”
./foo.sh &
pid=$!
wait $pid
echo “Completed foo.sh”
for I in 1 2 3 4 5
do
echo “bar.sh – Looping … number $i”
done
Resultado
Started bar.sh
Started foo.sh
foo.sh – Looping .. number 1
foo.sh – Looping .. number 2
foo.sh – Looping .. number 3
foo.sh – Looping .. number 4
foo.sh – Looping .. number 5
Completed foo.sh
bar.sh – Looping .. number 1
bar.sh – Looping .. number 2
bar.sh – Looping .. number 3
bar.sh – Looping .. number 4
bar.sh – Looping .. number 5
Completed bar.sh
$
Ejemplo 2 – Script sin comando de espera
Tenemos dos secuencias de comandos llamadas ‘foo.sh’ y secuencia de comandos ‘bar.sh’. El script ‘foo.sh’ imprime números entre 1 y 5 y el script bar.sh llamará al foo.sh y lo ejecutará en segundo plano, pero no esperará a que foo.sh complete y ejecute ambos scripts.
Secuencia de comandos – foo.sh
#!/bin/bash
for i in 1 2 3 4 5
do
echo “foo.sh – Looping … number $i”
done
Secuencia de comandos – bar.sh
#!/bin/bash
echo “Started bar.sh”
echo “Started foo.sh”
./foo.sh &
echo “Completed foo.sh”
for I in 1 2 3 4 5
do
echo “bar.sh – Looping … number $i”
done
Resultado
Started bar.sh
Started foo.sh
Completed foo.sh
bar.sh – Looping .. number 1
bar.sh – Looping .. number 2
bar.sh – Looping .. number 3
bar.sh – Looping .. number 4
bar.sh – Looping .. number 5
Completed bar.sh
$
foo.sh – Looping .. number 1
foo.sh – Looping .. number 2
foo.sh – Looping .. number 3
foo.sh – Looping .. number 4
foo.sh – Looping .. number 5
$
Ejemplo: 3 – Script con comando de espera y estado de retorno
El script ‘bar.sh’ llamará al foo.sh y lo ejecutará en segundo plano, obtendrá el PID de foo.sh y esperará a que se complete, una vez que se complete, iniciará el bucle bar.sh y se completará, finalmente, devolverá el código de salida del script foo.sh.
Secuencia de comandos: foo.sh (Exit estado = 0)
Secuencia de comandos – foo.sh
#!/bin/bash
for i in 1 2 3 4 5
do
echo “foo.sh – Looping … number $i”
done
Secuencia de comandos – bar.sh
#!/bin/bash
./foo.sh &
BPID=$!
wait $BPID
stat=$?
if [ $stat –eq 0 ]
then
echo “Exit status - $stat”
else
echo “Exit status - $stat”
fi
Resultado
foo.sh – Looping .. number 1
foo.sh – Looping .. number 2
foo.sh – Looping .. number 3
foo.sh – Looping .. number 4
foo.sh – Looping .. number 5
Exit status - 0
$
Secuencia de comandos: foo.sh (Exit estado = NO Cero)
Secuencia de comandos – foo.sh
#!/bin/bash
for i in 1 2 3 4 5
do
iiecho “foo.sh – Looping … number $i”
done
Secuencia de comandos – bar.sh
#!/bin/bash
./foo.sh &
BPID=$!
wait $BPID
stat=$?
if [ $stat –eq 0 ]
then
echo “Exit status - $stat”
else
echo “Exit status - $stat”
fi
Resultado
./foo.sh: line 4: iiecho: command not found
./foo.sh: line 4: iiecho: command not found
./foo.sh: line 4: iiecho: command not found
./foo.sh: line 4: iiecho: command not found
./foo.sh: line 4: iiecho: command not found
Exit status – 127
$
Conclusión
Tanto la espera como la suspensión son llamadas al sistema basadas en el tiempo en el sistema operativo. Comprobemos la diferencia entre el comando de espera y el de suspensión.
Espere: cuando el usuario quiere detener el proceso actual y libera todos los recursos retenidos por el proceso y espera a que se ejecute algún otro proceso. Necesitamos usar la notificación para que este proceso sea consciente de que comienza la ejecución nuevamente al completar otro proceso.
Suspensión: esta llamada al sistema se utiliza cuando el usuario desea detener el proceso actual durante algún tiempo. Mantiene los bloqueos en los recursos hasta que termina el tiempo de suspensión y comienza nuevamente la ejecución del proceso. Aquí el proceso tiene control durante toda la ejecución. por ejemplo, ejecuté algún comando en bash y quiere dormir durante algún tiempo, ya que esperaba algún resultado del comando ejecutado que se utilizará en la ejecución posterior del proceso actual.
