De wait-opdracht in Bash is een krachtig hulpmiddel voor het beheren van shell-scriptprocessen. Het wordt voornamelijk gebruikt om de uitvoering van een script te pauzeren totdat het opgegeven achtergrondproces is voltooid. Deze opdracht is handig in scripts die meerdere achtergrondtaken initiëren en hun voltooiing moeten synchroniseren voordat ze doorgaan met verdere taken. De wait-opdracht kan worden toegepast op individuele proces-ID's (PID's) of om te wachten op alle achtergrondprocessen die zijn geïnitieerd door de huidige shell-sessie. Door wait te gebruiken, kunt u ervoor zorgen dat uw script alleen verdergaat wanneer specifieke taken volledig zijn voltooid, waardoor uw automatiseringsprocessen betrouwbaarder en efficiënter worden.
Deze handleiding geeft praktische voorbeelden van het gebruik van de wait-opdracht in verschillende scenario's, zodat u begrijpt hoe u achtergrondprocessen in uw Bash-scripts effectief kunt beheren.
Het Bash-wachtcommando begrijpen
Het wait-commando in Bash is een ingebouwde functie die de uitvoering van de huidige shell stopt totdat de opgegeven taken zijn voltooid. Vervolgens retourneert het de afsluitstatus van het commando waarop het wachtte. Dit commando speelt een cruciale rol in de shell-uitvoeringsomgeving en is als zodanig in de meeste shells ingebouwd.
De algemene syntaxis van de wait-opdracht is als volgt:
wait [ID]In deze context vertegenwoordigt ID de proces- of taak-ID. Als er geen ID is opgegeven, pauzeert de wait-opdracht totdat alle onderliggende achtergrondtaken zijn voltooid. De wait-opdracht retourneert de exit-status van de laatste opdracht waarop is gewacht.
Als u bijvoorbeeld wilt pauzeren voor een achtergrondproces met PID 7654, gebruikt u:
wait 7654Als er meerdere processen worden opgegeven, wordt de wait-opdracht gepauzeerd totdat de processen zijn voltooid.
Navigeren door taakspecificaties met bash wait Command
Jobs worden gespecificeerd met behulp van de job specificatie (jobspec), die verwijst naar de processen waaruit de job bestaat. Een jobspec begint met een percentage symbool gevolgd door het job nummer (%n). Hier is een voorbeeld:
rsync -a /home /tmp/home &Deze opdracht wordt op de achtergrond uitgevoerd. De shell-taak-ID (tussen haakjes) en de proces-ID worden op uw terminal weergegeven. Om te pauzeren voor de taak, voert u de wait-opdracht uit, gevolgd door de taakspecificatie:
wait %2Gebruik de optie -n met het bash wait-commando
Met de optie -n kan het wait-commando slechts worden gepauzeerd totdat een enkele taak van de gegeven PID's of taakspecificaties is voltooid en wordt de afsluitstatus geretourneerd. Als er geen argumenten worden opgegeven, wacht wait -n tot een achtergrondtaak is voltooid en wordt de status van het afsluiten van de taak geretourneerd.
wait -n 45432 54346 76573In het bovenstaande voorbeeld print wait -n alleen de retourstatus van de job die als eerste wordt beëindigd; het toont niet de PID van de job. Als u de job-PID of jobspec wilt ophalen waarvoor de exitstatus wordt geretourneerd, gebruikt u de -p optie om het aan een variabele toe te wijzen:
wait -p job_id -n 45432 54346 76573De optie -p werd geïntroduceerd in Bash 5.1. Het gebruik van een oudere Bash-versie zal resulteren in een foutmelding “ongeldige optie”.
De optie -f verkennen met de opdracht bash wait
De optie -f geeft aan dat er gewacht moet worden om te pauzeren totdat elke PID of jobspec is beëindigd voordat de exitcode wordt geretourneerd in plaats van te retourneren wanneer de jobstatus is gewijzigd. Deze optie is alleen geldig wanneer job control is ingeschakeld, wat standaard alleen is ingeschakeld voor interactieve prompts.
Praktische voorbeelden van het wachtcommando
De wait-opdracht wordt doorgaans gebruikt in shell-scripts die onderliggende processen voortbrengen die parallel worden uitgevoerd. Laten we het volgende script maken om te illustreren hoe de opdracht werkt:
#!/bin/bash
sleep 30 &
process_id=$!
echo "PID: $process_id"
wait $process_id
echo "Exit status: $?"Laten we de code regel voor regel opsplitsen:
- De eerste regel, shebang, vertelt het besturingssysteem welke interpreter gebruikt moet worden om de rest van het bestand te parseren.
- We gebruiken het slaapcommando om een tijdrovend achtergrondproces te emuleren.
- $! is een interne Bash-variabele die de PID van de laatste taak op de achtergrond opslaat. In dit voorbeeld is dat de PID van het slaapcommando. We slaan de PID op in een variabele (process_id).
- Het PID-nummer wordt afgedrukt.
- De PID wordt doorgegeven aan het wachtcommando dat pauzeert totdat het slaapcommando is voltooid.
- De afsluitstatus van het wachtcommando wordt afgedrukt. $? is een interne Bash-variabele die de afsluitstatus bevat van de laatst uitgevoerde opdracht.
Als u het script uitvoert, wordt er zoiets als dit afgedrukt:
PID: 36353
Exit status: 0Hier is een voorbeeld waarbij de optie -n wordt gebruikt:
#!/bin/bash
sleep 3 &
sleep 30 &
sleep 5 &
wait -n
echo "First job completed."
wait
echo "All jobs completed."Wanneer het script wordt uitgevoerd, worden er 3 achtergrondprocessen gegenereerd. wait -n pauzeert totdat de eerste taak is voltooid en de echo-instructie is afgedrukt. wachtpauzes totdat alle onderliggende achtergrondtaken zijn voltooid.
First job completed.
All jobs completed.In het laatste voorbeeld wordt de optie -f uitgelegd. Open de terminal en voer het volgende uit:
sleep 3600 &
[1] 46671
wait 46671Open een andere terminal en stop het proces met het kill-commando:
kill -STOP 46671Zodra de processtatus verandert, wordt de wait-opdracht voltooid en wordt de exitcode van het proces geretourneerd.
Herhaal nu dezelfde stappen, maar gebruik deze keer wait -f $pid:
sleep 3600 &
wait -f 46671Stop het proces vanaf de andere terminal:
kill -STOP 46671Deze keer zal het wait commando niet compleet zijn. Het zal worden uitgevoerd totdat het slaapproces is beëindigd.
Geavanceerd gebruik van het wachtcommando
De wait-opdracht is vooral handig bij het beheren van meerdere processen in een script. Hiermee kunt u de uitvoeringsstroom regelen en ervoor zorgen dat specifieke processen zijn voltooid voordat andere beginnen. Laten we wat complexere voorbeelden bekijken om dit te illustreren.
Bash wacht op meerdere processen
Denk aan een scenario waarin meerdere processen op de achtergrond draaien en u pas actie moet ondernemen nadat ze zijn voltooid. Hier leest u hoe u de wait-opdracht kunt gebruiken om dit te bereiken:
#!/bin/bash
echo "Starting process 1..."
sleep 10 &
pid1=$!
echo "Starting process 2..."
sleep 15 &
pid2=$!
echo "Starting process 3..."
sleep 20 &
pid3=$!
echo "Waiting for processes to complete..."
wait $pid1 $pid2 $pid3
echo "All processes completed."Dit script start drie achtergrondprocessen die respectievelijk 10, 15 en 20 seconden slapen. We slaan de PID van elk proces op in een variabele. Vervolgens gebruiken we de wait-opdracht met alle drie de PID's als argumenten. Het script pauzeert bij de wait-opdracht totdat alle drie de processen zijn voltooid.
Gebruik Bash, wacht met een lus
U kunt wait ook gebruiken met een lus om meerdere processen te beheren. Hier is een voorbeeld:
#!/bin/bash
for i in {1..5}
do
echo "Starting process $i..."
sleep $i &
pids[${i}]=$!
done
echo "Waiting for processes to complete..."
for pid in ${pids[*]}; do
wait $pid
done
echo "All processes completed."In dit script starten we vijf achtergrondprocessen binnen een lus. Elk proces slaapt enkele seconden gelijk aan de index in de lus. We slaan de PID van elk proces op in een array. Nadat we alle processen hebben gestart, doorlopen we de array en gebruiken we de wait-opdracht om elk proces afzonderlijk te pauzeren. Het script pauzeert bij elke wachtopdracht totdat het bijbehorende proces is voltooid.
Conclusie
De wait-opdracht in Bash is essentieel voor het synchroniseren van achtergrondprocessen binnen uw scripts. Door te begrijpen hoe u wait gebruikt, kunt u de flow van uw script nauwkeuriger regelen, zodat taken in de gewenste volgorde worden voltooid. Of u nu met meerdere achtergrondtaken werkt of ervoor moet zorgen dat een specifiek proces is voltooid voordat u verdergaat, de wait-opdracht kan u helpen betrouwbaarder en voorspelbaarder scriptgedrag te bereiken. Overweeg wait te integreren in uw scripts om procesbeheer te verbeteren en de algehele scriptefficiëntie te verbeteren.
