Vänta kommandot i Bash är ett kraftfullt verktyg för att hantera skalskriptprocesser. Det används främst för att pausa körningen av ett skript tills den angivna bakgrundsprocessen är klar. Det här kommandot är praktiskt i skript som initierar flera bakgrundsjobb och måste synkronisera deras slutförande innan du fortsätter med ytterligare uppgifter. Vänta-kommandot kan tillämpas på individuella process-ID:n (PID) eller för att vänta på alla bakgrundsprocesser som initieras av den aktuella skalsessionen. Genom att använda wait kan du säkerställa att ditt skript bara går framåt när specifika uppgifter är helt slutförda, vilket gör dina automatiseringsprocesser mer tillförlitliga och effektiva.
Den här guiden ger praktiska exempel på hur du använder kommandot wait i olika scenarier, vilket hjälper dig att förstå hur du effektivt hanterar bakgrundsprocesser i dina Bash-skript.
Förstå kommandot Bash wait
Vänta-kommandot i Bash är en inbyggd funktion som stoppar exekveringen av det aktuella skalet tills de angivna jobben har avslutats. Den returnerar sedan utgångsstatus för kommandot som den väntade på. Detta kommando spelar en avgörande roll i skalexekveringsmiljön, och som sådan är det inbyggt i de flesta skal.
Den allmänna syntaxen för wait-kommandot är följande:
wait [ID]I detta sammanhang representerar ID processen eller jobb-ID. Om inget ID anges pausas kommandot wait tills alla underordnade bakgrundsjobb har slutförts. Vänta kommandot returnerar utgångsstatus för det senaste kommandot det väntade på.
Till exempel, för att pausa för en bakgrundsprocess med PID 7654, skulle du använda:
wait 7654Om flera processer är specificerade pausas kommandot wait tills de är klara.
Navigera jobbspecifikationer med bash wait-kommando
Jobb specificeras med hjälp av jobbspecifikationen (jobspec), som hänvisar till de processer som utgör jobbet. En jobbspec börjar med en procentsymbol följt av jobbnumret (%n). Här är ett exempel:
rsync -a /home /tmp/home &Detta kommando körs i bakgrunden. Skaljobb-ID (omges av parentes) och process-ID kommer att visas på din terminal. För att pausa för jobbet, kör kommandot wait följt av jobbspecifikationen:
wait %2Använder alternativet -n med kommandot bash wait
Alternativet -n tillåter att wait-kommandot endast pausas för ett enda jobb från de givna PID:erna eller jobbspecifikationerna att slutföra och returnerar dess utgångsstatus. Om inga argument tillhandahålls, väntar -n på att något bakgrundsjobb ska slutföras och returnera jobbets utgångsstatus.
wait -n 45432 54346 76573I exemplet ovan skriver wait -n endast ut returstatusen för jobbet som avslutas först; det visar inte jobbets PID. Om du vill få jobb-PID eller jobbspec för vilken utgångsstatusen returneras, använd -p alternativ för att tilldela den till en variabel:
wait -p job_id -n 45432 54346 76573Alternativet -p introducerades i Bash 5.1. Att använda en äldre Bash-version kommer att resultera i ett "ogiltigt alternativ"-fel.
Utforska alternativet -f med kommandot bash wait
Alternativet -f instruerar att vänta med att pausa för att varje PID eller jobbspec ska avslutas innan dess utgångskod returneras istället för att återvända när jobbstatusen ändras. Det här alternativet är endast giltigt när jobbkontroll är aktiverat, vilket är aktiverat som standard endast för interaktiva uppmaningar.
Praktiska exempel på väntekommandot
Kommandot wait används vanligtvis i skalskript som skapar underordnade processer som körs parallellt. För att illustrera hur kommandot fungerar, låt oss skapa följande skript:
#!/bin/bash
sleep 30 &
process_id=$!
echo "PID: $process_id"
wait $process_id
echo "Exit status: $?"Låt oss dela upp koden rad för rad:
- Den första raden, shebang, talar om för operativsystemet vilken tolk som ska användas för att analysera resten av filen.
- Vi använder sleep-kommandot för att efterlikna en tidskrävande bakgrundsprocess.
- $! är en intern Bash-variabel som lagrar PID för det senaste körda jobbet i bakgrunden. I det här exemplet är det PID för sömnkommandot. Vi lagrar PID i en variabel (process_id).
- PID-numret skrivs ut.
- PID skickas till väntekommandot som pausar tills vilokommandot slutförs.
- Utgångsstatusen för väntekommandot skrivs ut. $? är en intern Bash-variabel som håller utgångsstatusen för det senast körda kommandot.
Om du kör skriptet kommer det att skrivas ut ungefär så här:
PID: 36353
Exit status: 0Här är ett exempel med alternativet -n:
#!/bin/bash
sleep 3 &
sleep 30 &
sleep 5 &
wait -n
echo "First job completed."
wait
echo "All jobs completed."När skriptet körs skapar det 3 bakgrundsprocesser. wait -n pausar tills det första jobbet är klart och ekosatsen skrivs ut. vänta pauser för att alla barnbakgrundsjobb ska slutföras.
First job completed.
All jobs completed.Det sista exemplet förklarar alternativet -f. Öppna terminalen och kör:
sleep 3600 &
[1] 46671
wait 46671Öppna en annan terminal och stoppa processen med kommandot kill:
kill -STOP 46671När processstatusen ändras kommer väntekommandot att slutföras och processens avslutande kod kommer att returneras.
Upprepa nu samma steg, men den här gången använd wait -f $pid:
sleep 3600 &
wait -f 46671Stoppa processen från den andra terminalen:
kill -STOP 46671Den här gången kommer väntekommandot inte att slutföras. Den kommer att köras tills viloprocessen avslutas.
Avancerad användning av wait-kommandot
Vänta-kommandot blir särskilt användbart när du hanterar flera processer i ett skript. Det låter dig kontrollera exekveringsflödet och säkerställa att specifika processer har slutförts innan andra börjar. Låt oss fördjupa oss i några mer komplexa exempel för att illustrera detta.
Bash vänta på flera processer
Tänk på ett scenario där flera processer körs i bakgrunden och du måste agera först efter att ha slutfört dem. Så här kan du använda kommandot wait för att uppnå detta:
#!/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."Det här skriptet startar tre bakgrundsprocesser som sover i 10, 15 respektive 20 sekunder. Vi lagrar varje processs PID i en variabel. Sedan använder vi kommandot wait med alla tre PID:er som argument. Skriptet pausar vid wait-kommandot tills alla tre processerna har slutförts.
Använder Bash vänta med en loop
Du kan också använda vänta med en loop för att hantera flera processer. Här är ett exempel:
#!/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."I det här skriptet startar vi fem bakgrundsprocesser i en loop. Varje process sover i flera sekunder lika med dess index i slingan. Vi lagrar varje processs PID i en array. Efter att ha startat alla processer går vi igenom arrayen och använder kommandot wait för att pausa varje process individuellt. Skriptet pausas vid varje väntekommando tills motsvarande process har slutförts.
Slutsats
Vänta kommandot i Bash är viktigt för att synkronisera bakgrundsprocesser i dina skript. Genom att förstå hur man använder wait kan du kontrollera flödet av ditt skript mer exakt och säkerställa att uppgifterna slutförs i önskad ordning. Oavsett om du har att göra med flera bakgrundsjobb eller måste se till att en specifik process avslutas innan du fortsätter, kan wait-kommandot hjälpa dig att uppnå ett mer tillförlitligt och förutsägbart skriptbeteende. Överväg att integrera wait i dina skript för att förbättra processhanteringen och förbättra den övergripande skripteffektiviteten.
