Wait est une commande shell qui attend la fin d'un processus donné, puis renvoie son état de sortie. La commande Wait est utilisée pour attendre l'ID de processus et l'ID de travail particuliers et renvoyer leur état de terminaison.
Lors de l'exécution du grand flux d'automatisation, nous devons faire en sorte que quelques modules attendent la fin de l'ensemble de modules précédent et renvoient les données canalisées dans les modules suivants. Dans ce cas, nous pouvons utiliser la commande Wait jusqu'à ce que le module précédent soit terminé.
Comment fonctionne la commande d'attente
La commande d'attente utilisée pour surveiller le processus précédent dépend de l'état de retour du processus précédent, elle renverra l'état de sortie. Par exemple, si nous voulons attendre pour terminer un ID de processus particulier 13245, nous devons utiliser "wait 13245" lorsque la commande d'attente complète du processus 13245 renvoie les valeurs de retour de l'état de sortie 13245.
- wait PID (PID - ID de processus d'une commande, pour laquelle l'utilitaire doit attendre la fin).
- wait JID (JID - Job ID qui identifie un processus d'arrière-plan à attendre, applicable uniquement pour les appels d'attente dans l'environnement d'exécution du shell actuel).
La valeur de l'état de sortie de la commande d'attente dépend du dernier PID/JID spécifié. Lorsqu'un processus se termine anormalement, le statut de sortie sera supérieur à 128.
La commande Wait se termine avec la valeur 0 lorsqu'il appelle sans processus enfant et que tous les ID de processus sont connus par le shell actuel, ils se sont terminés. Si la commande d'attente détecte une erreur, elle renvoie une valeur comprise entre 1 et 126. Si le dernier identifiant de processus est inconnu, la commande d'attente se termine avec la valeur 127.
Exemples de commandes d'attente
Vérifions quelques scripts pour comprendre le fonctionnement de la commande d'attente.
Exemple :1 – Script avec la commande Wait
Nous avons deux scripts appelés scripts 'foo.sh' et 'bar.sh'. Le script 'Foo.sh' imprime les numéros entre 1 et 5 et le script 'bar.sh' appellera le foo.sh et l'exécutera en arrière-plan, obtiendra le PID de foo.sh et attendra qu'il se termine, une fois terminé, il le fera démarrer la boucle 'bar.sh' et terminer.
Script – foo.sh
#!/bin/bash
for i in 1 2 3 4 5
do
echo “foo.sh – Looping … number $i”
doneScript – 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”
doneRésultat
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
$Exemple 2 – Script sans commande d'attente
Nous avons deux scripts appelés scripts 'foo.sh' et 'bar.sh'. Le script 'foo.sh' imprime des nombres compris entre 1 et 5 et le script bar.sh appellera foo.sh et l'exécutera en arrière-plan, mais il n'attendra pas que foo.sh se termine et exécute les deux scripts.
Script – foo.sh
#!/bin/bash
for i in 1 2 3 4 5
do
echo “foo.sh – Looping … number $i”
doneScript – 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”
doneRésultat
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
$Exemple :3 – Script avec commande d'attente et état de retour
Le script 'bar.sh' appellera le foo.sh et l'exécutera en arrière-plan, obtiendra le PID de foo.sh et attendra qu'il se termine, une fois terminé, il démarrera la boucle bar.sh et se terminera, enfin, il renverra le code de sortie du script foo.sh.
Script – foo.sh (état de sortie =0)
Script - foo.sh
#!/bin/bash
for i in 1 2 3 4 5
do
echo “foo.sh – Looping … number $i”
doneScript – bar.sh
#!/bin/bash
./foo.sh &
BPID=$!
wait $BPID
stat=$?
if [ $stat –eq 0 ]
then
echo “Exit status - $stat”
else
echo “Exit status - $stat”
fiRésultat
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
$Script - foo.sh (état de sortie =NON zéro)
Script - foo.sh
#!/bin/bash
for i in 1 2 3 4 5
do
iiecho “foo.sh – Looping … number $i”
doneScript – bar.sh
#!/bin/bash
./foo.sh &
BPID=$!
wait $BPID
stat=$?
if [ $stat –eq 0 ]
then
echo “Exit status - $stat”
else
echo “Exit status - $stat”
fiRésultat
./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
$Conclusion
Wait et Sleep sont tous deux des appels système basés sur le temps dans le système d'exploitation. Vérifions la différence entre les commandes wait et sleep.
Attendre :Lorsque l'utilisateur veut arrêter le processus en cours et qu'il libère toutes les ressources détenues par le processus et attend qu'un autre processus s'exécute. Nous devons utiliser la notification pour informer ce processus que l'exécution recommence à la fin d'un autre processus.
Veille :cet appel système est utilisé lorsque l'utilisateur souhaite interrompre le processus en cours pendant un certain temps. Il maintient les verrous sur les ressources jusqu'à la fin du temps de sommeil et recommence l'exécution du processus. Ici, le processus a le contrôle tout au long de l'exécution. Par exemple, j'ai exécuté une commande sur bash et je veux dormir pendant un certain temps car j'attends une sortie de la commande exécutée qui sera utilisée dans l'exécution ultérieure du processus en cours.