Attendi il comando in Linux con esempi

Wait è un comando di shell che attende il completamento di un processo, quindi restituisce lo stato di uscita. Il comando Wait viene utilizzato per attendere un ID processo e un ID lavoro specifici e restituire il relativo stato di completamento.
Quando eseguiamo il flusso di automazione di grandi dimensioni, dobbiamo creare alcuni moduli, attendere fino al completamento del set precedente di moduli e restituire i dati inseriti nei moduli successivi, in questo caso possiamo utilizzare il comando Attendi fino al completamento del modulo precedente.
Come funziona il comando wait
Il comando Wait utilizzato per monitorare il processo precedente dipende dallo stato di ritorno del processo precedente, restituirà lo stato di uscita. Ad esempio, se vogliamo attendere il completamento di un determinato ID processo 13245, dovremmo utilizzare “wait 13245” quando il comando process 13245 complete wait restituisce i valori di ritorno dello stato di uscita 13245.
– wait PID (PID – ID di processo di un comando, per il quale l’utilità attenderà il completamento).
– wait JID (JID – job ID che identifica un processo in background su cui attendere, applicabile solo per le chiamate wait nell’attuale ambiente di esecuzione della shell).
Il valore dello stato di uscita del comando wait dipende dall’ultimo PID/JID specificato. Quando un processo termina in modo anomalo, lo stato di uscita sarà maggiore di 128.
Attendere che il comando esca con il valore 0
quando vengono chiamati senza un processo figlio e tutti gli ID di processo sono noti alla shell corrente, sono terminati. Se il comando wait rileva errori, restituisce qualsiasi valore compreso tra 1 e 126. Se l’ID dell’ultimo processo è sconosciuto, il comando wait restituisce il valore 127.
Attendi gli esempi di comandi
Controlliamo alcuni script per capire come funziona il comando wait.
Esempio 1 – Script con il comando Attendi
Abbiamo due script chiamati “foo.sh” e “bar.sh”. Stampa i numeri dallo script “Foo.sh” tra 1 e 5 e lo script “bar.sh” chiamerà foo.sh e lo eseguirà in background, otterrà il PID di foo.sh e attenderà il completamento, una volta completes , inizierai il ciclo “bar.sh” e finirai.
La sceneggiatura – foo.sh
#!/bin/bash
for i in 1 2 3 4 5
do
echo “foo.sh – Looping … number $i”
done
Sceneggiatura – 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
Risultato
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
$
Esempio 2 – Script senza comando wait
Abbiamo due script chiamati “foo.sh” e “bar.sh”. Lo script “foo.sh” stampa i numeri tra 1 e 5 e lo script bar.sh chiamerà foo.sh e lo eseguirà in background, ma non aspetterà che foo.sh finisca ed esegua entrambi gli script.
La sceneggiatura – foo.sh
#!/bin/bash
for i in 1 2 3 4 5
do
echo “foo.sh – Looping … number $i”
done
Sceneggiatura – 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
Risultato
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
$
Esempio: 3 – Script con comando wait e stato di ritorno
Lo script “bar.sh” chiamerà foo.sh e lo eseguirà in background, otterrà il PID di foo.sh e attenderà il suo completamento, una volta completato avvierà il ciclo bar.sh e si completerà, nell’allora restituirà il codice di uscita dello script foo.sh.
Script – foo.sh (Stato di uscita = 0)
Sceneggiatura – foo.sh
#!/bin/bash
for i in 1 2 3 4 5
do
echo “foo.sh – Looping … number $i”
done
Sceneggiatura – 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
Risultato
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 (stato di uscita = NON zero)
Sceneggiatura – foo.sh
#!/bin/bash
for i in 1 2 3 4 5
do
iiecho “foo.sh – Looping … number $i”
done
Sceneggiatura – 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
Risultato
./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
$
Conclusione
Wait e Sleep sono entrambe chiamate di sistema basate sul tempo nel sistema operativo. Controlliamo la differenza tra il comando wait e sleep.
Attendi: quando l’utente desidera interrompere il processo corrente e rilascia tutte le risorse di proprietà del processo e attende l’esecuzione di un altro processo. Dobbiamo usare la notifica per rendere questo processo consapevole che ricomincia l’esecuzione quando un altro processo viene completato.
Sleep: questa chiamata di sistema viene utilizzata quando l’utente desidera interrompere il processo corrente per un periodo di tempo. Mantiene il blocco della risorsa fino al termine del tempo di sospensione e avvia nuovamente l’esecuzione del processo. Qui il processo ha il controllo durante tutta l’esecuzione. Ad esempio, ho eseguito un comando su bash e voglio dormire per un po ‘perché mi aspettavo un output dal comando eseguito, che verrà utilizzato nell’ulteriore esecuzione del processo corrente.