Uppgifter och processer

Alla program som körs på Linux kallas bearbeta. Linux som multitasking-system kännetecknas av att många processer som tillhör en eller flera användare kan exekveras samtidigt. Du kan visa en lista över processer som körs för närvarande med kommandot ps till exempel enligt följande:

/home/larry# ps PID TT STAT TID KOMMANDO 24 3 S 0:03 (bash) 161 3 R 0:00 ps /home/larry#

Observera att kommandot som standard ps visar endast en lista över de processer som tillhör användaren som startade den. För att se alla processer som körs i systemet måste du utfärda kommandot ps -a . Processnummer(process-ID eller PID), listade i den första kolumnen, är unika nummer som systemet tilldelar varje pågående process. Den sista kolumnen, med rubriken COMMAND, anger namnet på kommandot som körs. I det här fallet innehåller listan processer som startats av användaren larry själv. Det finns många andra processer som körs i systemet, de full lista kan ses med kommandot ps-aux. Men bland kommandona som körs av användaren larry finns det bara bash (kommandoskalet för användaren larry) och själva kommandot ps. Bash-skalet kan ses köra samtidigt med kommandot ps. När användaren skrev in kommandot ps, började bash-skalet köra det. Efter laget ps har avslutat sitt arbete (processtabellen visas), återgår kontrollen till bash-processen. Sedan visar bash-skalet en prompt och väntar på ett nytt kommando.

En pågående process kallas också uppgift(jobb). Termerna process och uppgift används omväxlande. Men vanligtvis kallas en process för en uppgift när det betyder arbetsledning(jobbkontroll). Jobbkontroll är en kommandoskalsfunktion som ger användaren möjlighet att växla mellan flera jobb.

I de flesta fall kommer användare bara att köra en uppgift - detta kommer att vara det sista kommandot de angav i kommandoskalet. Men många skal (inklusive bash och tcsh) har funktioner arbetsledning(jobbkontroll), så att du kan köra flera kommandon samtidigt eller uppgifter(jobb) och, vid behov, växla mellan dem.

Jobbhantering kan vara användbart om du till exempel ska redigera en stor textfil och vill tillfälligt avbryta redigeringen för att göra någon annan operation. Du kan använda jobbhanteringsfunktionerna för att tillfälligt lämna redigeraren, återgå till skalprompten och utföra andra åtgärder. När de är klara kan du återgå till att arbeta med redigeraren och hitta den i samma tillstånd som den lämnades. Det finns många fler användbara användningsområden för jobbhanteringsfunktioner.

Förgrunds- och bakgrundsläge

Uppgifter kan vara antingen förgrund(förgrunden), eller bakgrund(bakgrund). Det kan bara finnas en uppgift i förgrunden vid varje given tidpunkt. Förgrundsuppgiften är uppgiften som du interagerar med; den tar emot indata från tangentbordet och skickar utdata till skärmen (såvida du naturligtvis inte dirigerat om ingången eller utmatningen någon annanstans). Mot, bakgrundsjobb inte ta emot input från terminalen; Sådana jobb kräver vanligtvis inte användarinteraktion.

Vissa uppgifter tar väldigt lång tid att slutföra och inget intressant händer medan de körs. Ett exempel på sådana uppgifter är att kompilera program, samt komprimera stora filer. Det finns ingen anledning att stirra på skärmen och vänta på att dessa uppgifter ska slutföras. Sådana jobb borde köras in bakgrund. Under denna tid kan du arbeta med andra program.

För att kontrollera exekveringen av processer i Linux tillhandahålls en överföringsmekanism signaler. En signal är processernas förmåga att utbyta vanliga kortmeddelanden direkt med hjälp av systemet. Signalmeddelandet innehåller ingen information förutom signalnumret (för enkelhetens skull kan ett namn som är fördefinierat av systemet användas istället för ett nummer). För att sända en signal behöver en process bara använda ett systemanrop döda(), och för att ta emot signalen behöver du ingenting. Om en process behöver svara på en signal på något speciellt sätt kan den registrera sig hanterare, och om det inte finns någon hanterare kommer systemet att reagera för det. Vanligtvis gör detta att processen som tog emot signalen avslutas omedelbart. Signalhanteraren startar asynkront, omedelbart efter att ha tagit emot signalen, oavsett vad processen gör vid tillfället.

Två signaler - nummer 9 ( DÖDA) och 19 ( SLUTA) - bearbetas alltid av systemet. Den första av dem behövs för att säkert döda processen (därav namnet). Signal SLUTA avbryter process: i detta tillstånd tas processen inte bort från processtabellen, men exekveras inte förrän den tar emot signal 18 ( FORTS) - varefter det kommer att fortsätta att fungera. I Linux-kommandoskalet, signalen SLUTA kan skickas till den aktiva processen med hjälp av en escape-sekvens Ctrl -Z .

Signal nummer 15 ( TERMIN) tjänar till att avbryta jobbet. På avbrott(avbryta) jobbprocessen dör. Jobben avbryts vanligtvis av en flyktsekvens Ctrl -C. Det finns inget sätt att återställa ett avbrutet jobb. Du bör också vara medveten om att vissa program fångar upp signalen TERMIN(med hjälp av en hanterare), så att trycka på en tangentkombination Ctrl -C(o) får inte avbryta processen omedelbart. Detta görs för att programmet ska kunna förstöra spår av sitt arbete innan det är klart. I praktiken kan vissa program inte alls avbrytas på detta sätt.

Flytta till bakgrunden och förstöra jobb

Låt oss börja med enkelt exempel. Låt oss titta på ja-kommandot, som vid första anblicken kan verka värdelöst. Detta kommando skickar en oändlig ström av strängar som består av tecknet y till standardutdata. Låt oss se hur detta kommando fungerar:

/home/larry# ja ååååååå

Sekvensen av sådana linjer kommer att fortsätta på obestämd tid. Du kan förstöra denna process genom att skicka den en avbrottssignal, d.v.s. genom att trycka på Ctrl -C. Låt oss göra saker annorlunda nu. För att förhindra att denna ändlösa sekvens visas på skärmen kommer vi att omdirigera standardutgången för yes-kommandot till /dev/null . Som du kanske vet fungerar /dev/null-enheten som ett "svart hål": all data som skickas till den här enheten går förlorad. Med den här enheten är det mycket bekvämt att bli av med för mycket utdata från vissa program.

/home/larry# ja > /dev/null

Nu visas ingenting på skärmen. Skalprompten returneras dock inte heller. Detta beror på att kommandot yes fortfarande körs och skickar sina meddelanden som består av bokstäverna y till /dev/null . Du kan också förstöra denna uppgift genom att skicka en avbrottssignal.

Låt oss nu säga att du vill att ja-kommandot ska fortsätta att fungera, men också för att returnera skalprompten till skärmen så att du kan arbeta med andra program. För att göra detta kan du sätta ja-kommandot i bakgrunden, och det kommer att fungera där utan att kommunicera med dig.

Ett sätt att sätta en process i bakgrunden är att lägga till en & i slutet av kommandot. Exempel:

/home/larry# yes > /dev/null & + 164 /home/larry#

Budskapet är Jobb nummer(jobbnummer) för processen ja. Kommandoskalet tilldelar ett jobbnummer till varje jobb som det körs. Eftersom yes är det enda körbara jobbet tilldelas det numret 1. Numret 164 är identifikationsnumret som är associerat med denna process (PID), och detta nummer ges också till processen av systemet. Som vi kommer att se senare kan en process nås genom att ange båda dessa nummer.

Så nu har vi en ja-process som körs i bakgrunden, som kontinuerligt skickar en ström av y till /dev/null-enheten. För att ta reda på statusen för denna process måste du utföra kommandot jobb, som är ett internt skalkommando.

/home/larry# jobb + Kör ja >/dev/null & /home/larry#

Vi ser att det här programmet verkligen fungerar. För att ta reda på status för en uppgift kan du också använda kommandot ps, som visas ovan.

För att överföra en signal till processen (oftast finns det ett behov avbryta jobb) används verktyget döda. Detta kommando ges antingen ett jobbnummer eller ett PID som argument. En valfri parameter är numret på signalen som måste skickas till processen. Som standard skickas signalen TERMIN. I ovanstående fall var jobbnumret 1, så kommandot döda %1 kommer att avbryta jobbet. När ett jobb nås av dess nummer (istället för dess PID), måste det numret föregås av en procentsymbol ("%") på kommandoraden.

Låt oss nu skriva in kommandot jobb igen för att kontrollera resultatet av föregående åtgärd:

/home/larry# jobb Upphört ja >/dev/null

Faktum är att jobbet förstörs, och nästa gång du anger kommandot jobb kommer det inte att finnas någon information om det på skärmen.

Du kan också döda ett jobb med hjälp av processidentifieringsnumret (PID). Detta nummer, tillsammans med jobbets identifieringsnummer, anges när jobbet startar. I vårt exempel var PID-värdet 164, så kommandot döda 164 skulle motsvara kommandot döda %1. När du använder PID som argument för kill-kommandot behöver du inte ange tecknet "%".

Pausa och återuppta jobb

Låt oss först starta processen med yes-kommandot i förgrunden, som gjordes tidigare:

/home/larry# ja > /dev/null

Som tidigare, eftersom processen körs i förgrunden, återgår inte skalprompten till skärmen.

Nu istället för att avbryta uppgiften med en tangentkombination Ctrl -C, uppgiften är möjlig uppskjuta(avbryta, bokstavligen - att avbryta), skickar honom en signal SLUTA. För att pausa en uppgift måste du trycka på lämplig tangentkombination, vanligtvis denna Ctrl -Z .

/home/larry# ja > /dev/null Ctrl -Z+ Slutade ja >/dev/null /home/larry#

Den avbrutna processen körs helt enkelt inte. Den förbrukar inte processorresurser. En avstängd uppgift kan startas från samma punkt som om den inte hade avbrutits.

För att återuppta jobbet som körs i förgrunden kan du använda kommandot fg(från ordet förgrund - förgrund).

/home/larry# fg yes >/dev/null

Kommandoskalet kommer återigen att visa kommandonamnet så att användaren vet vilken uppgift han befinner sig i. det här ögonblicket lanseras i förgrunden. Låt oss pausa den här uppgiften igen genom att trycka på tangenterna Ctrl -Z, men den här gången låt oss starta den i bakgrunden med kommandot bg(från ordet bakgrund - bakgrund). Detta kommer att få processen att köras som om den hade körts med ett kommando med en & i slutet (som gjordes i föregående avsnitt):

/home/larry# bg + yes $>$/dev/null & /home/larry#

Skalprompten returneras. Nu laget jobb måste visa att processen ja arbetar faktiskt för tillfället; denna process kan dödas med kommandot döda, som det gjordes tidigare.

Du kan inte använda kortkommandot för att pausa en uppgift som körs i bakgrunden Ctrl -Z. Innan du pausar ett jobb måste det tas i förgrunden med kommandot fg och bara då sluta. Alltså kommandot fg kan tillämpas på antingen avbrutna jobb eller på ett jobb som körs i bakgrunden.

Det är stor skillnad mellan bakgrundsjobb och avstängda jobb. En avstängd uppgift fungerar inte - inga pengar spenderas på det beräkningskraft processor. Det här jobbet utför ingen åtgärd. En avstängd uppgift upptar en viss mängd dator-RAM efter en tid, kommer kärnan att pumpa ut denna del av minnet HDD « poste restante" Däremot körs ett bakgrundsjobb, använder minne och gör vissa saker som du kanske vill göra, men du kanske arbetar med andra program samtidigt.

Jobb som körs i bakgrunden kan försöka visa lite text på skärmen. Detta kommer att störa arbetet med andra uppgifter.

/home/larry# ja &

Här har standardutdata inte omdirigerats till /dev/null-enheten, så en oändlig ström av y-tecken kommer att skrivas ut på skärmen. Den här tråden kan inte stoppas eftersom tangentkombinationen Ctrl -C påverkar inte jobb i bakgrunden. För att stoppa denna utmatning måste du använda kommandot fg, vilket kommer att ta uppgiften i förgrunden, och sedan förstöra uppgiften med en tangentkombination Ctrl -C .

Låt oss göra en anmärkning till. Vanligtvis i lag fg och laget bg påverka de jobb som senast var avstängda (dessa jobb kommer att markeras med en +-symbol bredvid jobbnumret om du anger kommandot jobb). Om ett eller flera jobb körs samtidigt kan jobb placeras i förgrunden eller bakgrunden genom att ange kommandon som argument fg eller kommandon bg deras identifikationsnummer (jobb-ID). Till exempel kommandot fg %2 sätter jobb nummer 2 till fronten och kommandot bg %3 sätter jobb nummer 3 i bakgrunden. Använd PID som kommandoargument fg Och bg det är förbjudet.

Dessutom, för att få ett jobb i förgrunden, kan du helt enkelt ange dess nummer. Ja, laget %2 kommer att motsvara kommandot fg %2 .

Det är viktigt att komma ihåg att jobbkontrollfunktionen hör till skalet. Lag fg , bg Och jobbär interna team skal. Om du av någon anledning använder ett kommandoskal som inte stöder jobbhanteringsfunktioner, kommer du inte att hitta dessa (och liknande) kommandon i det.

Att administrera en server som kör Linux åtföljs ofta av flera manipulationer av kommandon i terminalfönstret. Detta är en bekant bild för dem som administrerar servrar på Linux, och i vissa fall är det bekvämt att köra kommandon i bakgrunden. Detta kan mycket väl användas i praktiken, och det är värt att notera anledningarna till att det kan vara användbart:
— När terminalen är överbelastad med ett gäng meddelanden och det inte är möjligt att utföra ytterligare åtgärder parallellt;
— Om du stänger terminalen stoppas den aktuella processen och dess underordnade processer;
Dessa problem kan enkelt lösas, vi måste helt separera den pågående processen från kontrollterminalen.

I det här inlägget ska vi titta på Linuxs användbara förmåga att köra kommandon i bakgrunden. Med andra ord kommer processen du startar att exekveras separat från kontrollterminalen.

Hur man kör kommandon eller processer i bakgrunden
Om din process körs i ett terminalfönster kan du pausa den med kommandot Ctrl+Z, säkert många människor vet detta och kommer att tänka, så vad. Och här är det som är intressant, efter att ha avbrutit processen, kan vi fortsätta den i bakgrunden, för att göra detta måste vi ange kommandot

Efter att ha angett detta kommando kommer processen att fortsätta, men i bakgrunden. För att se alla processer som körs i bakgrunden kan du ange kommandot

Låt oss titta på ett enkelt exempel på hur detta kan tillämpas. Låt oss säga att vi har en , som vi behöver packa upp, men vi har inte tid att vänta, och vi vill arbeta parallellt.

Packar upp arkivet i bakgrunden

$ tar -czf home.tar.gz .

Klick Cntr+Z, ange sedan kommandona

$bg$jobb

Det andra sättet är att lägga till en & i slutet av kommandot, detta kommer att tala om för systemet att köra kommandot i bakgrunden.

$ tar -czf home.tar.gz . &$jobb

Denna metod tillåter processer att köras i bakgrunden, men STDIN, STDOUT, STDERRär fortfarande anslutna till terminalen. Låt oss nu se till att processen körs även när terminalen är stängd.

Utför en process efter att ha stängt terminalfönstret
För att hålla processen igång även efter att ha stängt terminalfönstret kan vi använda kommandot förneka. Det kommer att "haka av" processen från skalet i terminalfönstret, varefter den kommer att exekveras även efter att konsolfönstret stängs.
Låt oss titta på ett exempel på hur du använder standardkommandot rsync, låt oss försöka köra det i bakgrunden och koppla bort processen från terminalen.

$ sudo rsync Mallar/* /var/www/html/ & $ jobb $ disown -h %1 $ jobb

Du kan också använda kommandot nohup, kommer det att tillåta processen att fortsätta köras även när användaren lämnar systemskalet.

$ nohup tar -czf iso.tar.gz Mallar/* & $ jobb

Hur man separerar en process från Linux-kontrollterminalen
För att helt separera processen från kontrollterminalen kan du också använda ett kommando som kommer att vara effektivt när du använder ett grafiskt användargränssnitt (GUI), till exempel webbläsaren Firefox.

$firefox/dev/null &

I Linux-system(och på nästan alla Unix-system) /dev/null är en speciell enhetsfil, som också kallas en "nullenhet". Att skriva till den utförs framgångsrikt, oavsett mängden information som registreras från den är likvärdig med att läsa slutet av filen (EOF).

Förra gången pratade vi om att arbeta med input, output och felströmmar i bash-skript, filbeskrivningar och omdirigering av ström. Nu vet du redan tillräckligt för att skriva något eget. I det här skedet av att bemästra bash kan du mycket väl ha frågor om hur man hanterar körande skript och hur man automatiserar deras lansering.

Hittills har vi skrivit skriptnamn på kommandoraden och tryckt på Enter, vilket gör att programmen körs omedelbart, men så är inte fallet. det enda sättet anropsskript. Idag ska vi prata om hur ett skript kan fungera med Linux-signaler, om olika tillvägagångssätt för att köra skript och hantera dem medan de körs.

Linux-signaler

I Linux finns det mer än tre dussin signaler som genereras av systemet eller applikationerna. Här är en lista över de mest använda, som säkerligen kommer till användning när man utvecklar skript kommandorad.

Signalkod	namn	Beskrivning
1	SIGHUP	Stänger terminalen
2	SIGINT	Signal för att stoppa processen av användaren från terminalen (CTRL + C)
3	SIGQUIT	Signal för att stoppa en process av användaren från terminalen (CTRL + \) med en minnesdump
9	SIGKILL	Ovillkorligt avslutande av processen
15	SIGTERM	Bearbetningssignal för begäran om avslutande
17	SIGSTOPPA	Att tvinga en process att avbrytas men inte avslutas
18	SIGTSTP	Pausar en process från terminalen (CTRL+Z) men stänger inte av
19	SIGCONT	Fortsätt köra en tidigare stoppad process

Om bash-skalet får en SIGHUP-signal när du stänger terminalen, avslutas den. Innan den avslutas skickar den en SIGHUP-signal till alla processer som körs i den, inklusive körande skript.

SIGINT-signalen gör att driften tillfälligt stoppas. Linuxkärnan slutar tilldela processortid till skalet. När detta händer, meddelar skalet processer genom att skicka dem en SIGINT-signal.

Bash-skript kontrollerar inte dessa signaler, men de kan känna igen dem och utföra vissa kommandon för att förbereda skriptet för de konsekvenser som signalerna orsakar.

Skickar signaler till manus

Bash-skalet låter dig skicka signaler till skript med kortkommandon. Detta är väldigt praktiskt om du tillfälligt behöver stoppa ett körande skript eller avsluta dess operation.

Att avsluta en process

Kombination CTRL-tangenter+C genererar en SIGINT-signal och skickar den till alla processer som körs i skalet, vilket får dem att avslutas.

Låt oss köra följande kommando i skalet:

$ sömn 100
Efter det kommer vi att slutföra arbetet med tangentkombinationen CTRL + C.

Avsluta en process från tangentbordet

Tillfälligt stoppa processen

Tangentkombinationen CTRL + Z genererar SIGTSTP-signalen, som avbryter processen men inte avslutar den. En sådan process finns kvar i minnet och dess arbete kan återupptas. Låt oss köra kommandot i skalet:

$ sömn 100
Och stoppa det tillfälligt med tangentkombinationen CTRL + Z.

Pausa processen

Siffran inom hakparenteser är jobbnumret som skalet tilldelar processen. Skalet behandlar processer som körs inom det som jobb med unika nummer. Den första processen tilldelas nummer 1, den andra - 2, och så vidare.

Om du pausar ett jobb bundet till ett skal och försöker avsluta det, kommer bash att utfärda en varning.

Du kan visa avstängda jobb med följande kommando:

Ps –l

Uppgiftslista

I kolumnen S, som visar processstatus, visas T för avbrutna processer. Detta indikerar att kommandot antingen är avstängt eller i spårningsläge.

Om du behöver avsluta en avstängd process kan du använda kommandot kill. Du kan läsa detaljer om det.

Hennes samtal ser ut så här:

Döda processID

Signalavlyssning

För att aktivera Linux-signalspårning i ett skript, använd trap-kommandot. Om skriptet tar emot den signal som anges när det här kommandot anropas, bearbetar det det självständigt, medan skalet inte kommer att bearbeta en sådan signal.

Trappkommandot låter skriptet svara på signaler som annars skulle bearbetas av skalet utan dess ingripande.

Låt oss titta på ett exempel som visar hur trap-kommandot specificerar koden som ska köras och en lista över signaler, separerade med mellanslag, som vi vill fånga upp. I det här fallet är det bara en signal:

#!/bin/bash trap "echo " Trapped Ctrl-C"" SIGINT echo Detta är ett testskript count=1 medan [ $count -le 10 ] eko "Loop #$count" sleep 1 count=$(($ räkna + 1)) gjort
Trappkommandot som används i det här exemplet ger utdata textmeddelande närhelst den upptäcker en SIGINT-signal, som kan genereras genom att trycka på Ctrl + C på tangentbordet.

Signalavlyssning

Varje gång du trycker på CTRL + C , kör skriptet ekokommandot som anges när spårning anropas istället för att låta skalet avsluta det.

Du kan fånga upp skriptutgångssignalen genom att använda namnet på EXIT-signalen när du anropar trap-kommandot:

#!/bin/bash trap "echo Goodbye..." EXIT count=1 medan [ $count -le 5 ] eko "Loop #$count" sleep 1 count=$(($count + 1)) klar

Avlyssning av skriptutgångssignalen

När skriptet avslutas, antingen normalt eller på grund av en SIGINT-signal, kommer skalet att fånga upp och utföra ekokommandot.

Modifiering av avlyssnade signaler och annullering av avlyssning

För att modifiera signaler som fångas upp av skriptet kan du köra trap-kommandot med nya parametrar:

#!/bin/bash trap "eko "Ctrl-C är fångad."" SIGINT count=1 medan [ $count -le 5 ] eko "Loop #$count" sleep 1 count=$(($count + 1) ) gjort fälla "eko "Jag modifierade fällan!"" SIGINT count=1 medan [ $count -le 5 ] gör eko "Second Loop #$count" sleep 1 count=$(($count + 1)) done

Modifiering av signalavlyssning

Efter modifiering kommer signalerna att behandlas på ett nytt sätt.

Signalavlyssning kan också avbrytas genom att helt enkelt utföra trap-kommandot, skicka ett dubbelstreck och signalnamnet:

#!/bin/bash trap "eko "Ctrl-C är fångad."" SIGINT count=1 medan [ $count -le 5 ] eko "Loop #$count" sleep 1 count=$(($count + 1) ) klar fälla -- SIGINT eko "Jag tog precis bort fällan" count=1 medan [ $count -le 5 ] gör eko "Second Loop #$count" sleep 1 count=$(($count + 1)) done
Om skriptet tar emot en signal innan avlyssningen avbryts kommer det att bearbeta den enligt beskrivningen i nuvarande lag fälla. Låt oss köra skriptet:

$ ./myscript
Och tryck på CTRL + C på tangentbordet.

Signal som avlyssnas innan avlyssningen avbröts.

Det första trycket på CTRL + C inträffade vid tidpunkten för skriptkörning, när signalavlyssning var i kraft, så skriptet körde ekokommandot som tilldelats signalen. Efter att exekveringen nådde unhook-kommandot fungerade CTRL + C-kommandot som vanligt och avslutade skriptet.

Kör kommandoradsskript i bakgrunden

Ibland tar bash-skript lång tid att slutföra en uppgift. Du kan dock behöva kunna arbeta normalt på kommandoraden utan att vänta på att skriptet ska slutföras. Det är inte så svårt att genomföra.

Om du har sett listan över processer som matas ut av kommandot ps kan du ha märkt processer som körs i bakgrunden och inte är bundna till en terminal.
Låt oss skriva följande manus:

#!/bin/bash count=1 medan [ $count -le 10 ] sover 1 count=$(($count + 1)) klar
Låt oss köra det genom att ange et-tecken (&) efter namnet:

$ ./myscipt &
Detta kommer att få den att köras som en bakgrundsprocess.

Kör ett skript i bakgrunden

Skriptet kommer att startas i en bakgrundsprocess, dess identifierare kommer att visas i terminalen och när exekveringen är klar kommer du att se ett meddelande om detta.

Observera att även om skriptet körs i bakgrunden, fortsätter det att använda terminalen för att mata ut meddelanden till STDOUT och STDERR, vilket betyder att texten eller felmeddelanden kommer att synas i terminalen.

Lista över processer

Med detta tillvägagångssätt, om du avslutar terminalen, kommer skriptet som körs i bakgrunden också att avslutas.

Vad händer om du vill att skriptet ska fortsätta köras efter att du har stängt terminalen?

Utför skript som inte avslutas när terminalen stängs

Skript kan köras i bakgrundsprocesser även efter att terminalsessionen avslutats. För att göra detta kan du använda kommandot nohup. Detta kommando låter dig köra ett program genom att blockera SIGHUP-signaler som skickas till processen. Som ett resultat kommer processen att exekveras även när du lämnar terminalen där den startades.

Låt oss tillämpa den här tekniken när vi kör vårt skript:

Nohup ./myscript &
Detta är vad som kommer att matas ut till terminalen.

Team nohup

Kommandot nohup kopplar bort en process från terminalen. Detta innebär att processen kommer att förlora referenser till STDOUT och STDERR. För att inte förlora data som matas ut av skriptet, omdirigerar nohup automatiskt meddelanden som kommer in i STDOUT och STDERR till filen nohup.out.

Observera att om du kör flera skript från samma katalog, kommer deras utdata att hamna i en enda nohup.out-fil.

Se uppdrag

Kommandot jobb låter dig se aktuella jobb som körs i skalet. Låt oss skriva följande manus:

#!/bin/bash count=1 medan [ $count -le 10 ] eko "Loop #$count" sleep 10 count=$(($count + 1)) klar
Låt oss köra det:

$ ./myscript
Och stoppa det tillfälligt med tangentkombinationen CTRL + Z.

Köra och pausa ett skript

Låt oss köra samma skript i bakgrunden, samtidigt som vi omdirigerar skriptets utdata till en fil så att den inte visar något på skärmen:

$ ./myscript > outfile &
Genom att nu köra kommandot jobb kommer vi att se information om både det avstängda skriptet och det som körs i bakgrunden.

Få information om skript

Omkopplaren -l när du anropar kommandot jobb indikerar att vi behöver information om process-ID:n.

Startar om avstängda jobb

För att starta om skriptet i bakgrunden kan du använda kommandot bg.

Låt oss köra skriptet:

$ ./myscript
Tryck på CTRL + Z, vilket tillfälligt stoppar exekveringen. Låt oss köra följande kommando:

$bg

bg kommando

Skriptet körs nu i bakgrunden.

Om du har flera avbrutna jobb kan du skicka jobbnumret till kommandot bg för att starta om ett specifikt jobb.

För att starta om ett jobb i normalt läge använd kommandot fg:

Planerar att köra skript

Linux erbjuder ett par sätt att köra bash-skript vid en given tidpunkt. Dessa är at-kommandot och cron-jobbschemaläggaren.

Kommandot at ser ut så här:

Vid [-f filnamn] tid
Detta kommando känner igen många tidsformat.

• Standard, anger timmar och minuter, till exempel - 10:15.
• Använda AM/PM-indikatorer, före eller efter middagstid, till exempel - 22:15.
• Använd speciella namn som nu, middag, midnatt.

Förutom att kunna ange när ett jobb ska köras, kan kommandot at även skickas ett datum med ett av dess format som stöds.

• Ett standarddatumformat där datumet skrivs med mönstren MMDDYY, MM/DD/YY eller DD.MM.YY.
• En textrepresentation av datumet, till exempel 4 juli eller 25 december, medan året kan anges, eller så kan du klara dig utan det.
• Inspelning som nu + 25 minuter.
• Inspelningsvisning 22:15 imorgon.
• Inspelningstyp 10:15 + 7 dagar.

Låt oss inte gå djupare in på det här ämnet, låt oss titta på ett enkelt användningsfall för kommandot:

$ vid -f ./myscript nu

Schemalägg jobb med kommandot at

-M-växeln när du anropar på används för att skicka vad skriptet matar ut till e-post, om systemet är konfigurerat därefter. Om du skickar e-postär inte möjligt, kommer den här omkopplaren helt enkelt att undertrycka utgången.

För att se listan över jobb som väntar på att utföras kan du använda kommandot atq:

Lista över pågående uppgifter

Tar bort väntande jobb

Kommandot atrm låter dig ta bort ett väntande jobb. När du ringer det, ange uppgiftsnumret:

$atrm 18

Ta bort ett jobb

Kör skript enligt ett schema

Att schemalägga dina skript att köras en gång med hjälp av kommandot at kan göra livet lättare i många situationer. Men vad händer om du vill att skriptet ska köras vid samma tidpunkt varje dag, eller en gång i veckan eller en gång i månaden?

Linux har ett crontab-verktyg som låter dig schemalägga skript som måste köras regelbundet.

Crontab körs i bakgrunden och, baserat på data i så kallade cron-tabeller, kör schemalagda jobb.

För att visa en befintlig cron-jobbtabell, använd följande kommando:

$ crontab –l
När du schemalägger ett skript att köras enligt ett schema, accepterar crontab data om när jobbet behöver köras i följande format:

Minut, timme, dag i månaden, månad, veckodag.
Om du till exempel vill att ett visst skript med namnet kommando ska köras varje dag klockan 10:30, kommer detta att motsvara följande post i uppgiftstabellen:

30 10 * * * kommando
Här indikerar jokertecknet "*" som används för fälten dag i månad, månad och veckodag att cron ska köra kommandot varje dag i varje månad klockan 10:30.

Om du till exempel vill att skriptet ska köras 16:30 varje måndag, måste du skapa följande post i uppgiftstabellen:

30 16 * * 1 kommando
Numreringen av veckodagarna börjar från 0, 0 betyder söndag, 6 betyder lördag. Här är ett annat exempel. Här kommer kommandot att utföras kl. 12.00 den första dagen i varje månad.

00 12 1 * * kommando
Månader är numrerade från 1.
För att lägga till en post i en tabell måste du anropa crontab med -e-växeln:

Crontab –e
Sedan kan du ange kommandon för schemagenerering:

30 10 * * * /home/likegeeks/Desktop/myscript
Tack vare detta kommando kommer skriptet att anropas varje dag kl. 10:30. Om du stöter på felet "Resurs tillfälligt otillgänglig" kör du kommandot nedan som root:

$ rm -f /var/run/crond.pid
Du kan organisera periodisk lansering av skript med cron ännu enklare genom att använda flera speciella kataloger:

/etc/cron.hourly /etc/cron.daily /etc/cron.weekly /etc/cron.monthly
Om du placerar en skriptfil i en av dem kommer den att köras varje timme, dagligen, veckovis eller månadsvis.

Kör skript vid inloggning och skalstart

Du kan automatisera lanseringen av skript baserat på olika händelser, som användarinloggning eller skallansering. Du kan läsa om filer som behandlas i sådana situationer. Det här är till exempel följande filer:

$HOME/.bash_profile $HOME/.bash_login $HOME/.profile
För att köra ett skript vid inloggning, placera dess anrop i filen .bash_profile.

Hur är det med att köra skript när du öppnar en terminal? .bashrc-filen hjälper dig att organisera detta.

Resultat

Idag diskuterade vi frågor som rör förvaltning livscykel skript, vi pratade om hur man kör manus i bakgrunden, hur man schemalägger exekvering av dem. Nästa gång, läs om funktioner i bash-skript och biblioteksutveckling.

Kära läsare! Använder du verktyg för att schemalägga kommandoradsskript så att de körs enligt ett schema? Om ja, berätta gärna om dem.

Linux-terminaltjänsten körs som standard i single-tasking-läge. Detta innebär att varje sjösatt besättning blockerar terminalen tills den är klar. Detta tillvägagångssätt är inte praktiskt när man kör program som kräver lång körningstid. Det här problemet kan lösas på två sätt: öppna ett extra terminalfönster och kör ett annat kommando i det, eller använd bakgrundsläget. Alla nuvarande operativsystem, inklusive Linux, är multitasking, vilket innebär möjligheten att köra flera program samtidigt.

Hur kan jag köra en brigad i bakgrunden så att jag omedelbart kan komma åt kommandoradsgränssnittet? En besättning som har tvingats springa kallas en bakgrundsprocess. Bakgrundsprocesser visas inte på skärmen. Till exempel körs Apache HTTPD-servern i bakgrunden för att betjäna webbsidor. Du kan sätta ett skalskript eller vilket kommando som helst i lågprioritetsläge. En uppgift (till exempel en besättning eller ett skript) kan placeras i bakgrunden genom att lägga till ett "&" i slutet av kommandoraden. Detta uttalande sätter kommandot i bakgrunden och frigör utrymme i terminalen. Ett team som kör i bakgrunden kallas ett jobb. Medan bakgrundskommandot körs är det möjligt att utföra andra kommandon. Syntaxen är som följer:

kommando & skriptnamn & /sökväg/till/kommando arg1 arg2 & kommando-1 | kommando-2 arg1 & kommando-1 | kommando-2 -arg1 -arg2 >/sökväg/till/utgång &

För att köra program i bakgrunden utan att blockera terminalfönstret måste du använda den speciella "&"-instruktören. Placera detta tecken i slutet av raden efter att ha angett kommandonamn, alternativ och inmatningsparametrar. I allmän syn denna sekvens kan anges som "kommandonamn -option input_parameter &".

ls ~/* > ~/test-fil.txt &
18960

Efter att ha tryckt på Enter-knappen startar programmet automatiskt i bakgrunden. I det här fallet kommer terminalen att visa en rad med följande innehåll "[task_number] process_identifier" och kommer att uppmana dig att ange ett nyskapat kommando.

Hitta kommandon som körs i bakgrunden i Linux

Kör följande kommando:

Exempel på datautmatning:

Kör find / -iname "*.c" 2> /dev/null > /tmp/output.txt &
+ Kör grep -R "hostNamed" / 2> /dev/null > /tmp/grep.txt &

Var finns orderidentifierarna.

För att visa process-ID:n för jobb-ID:n utöver standardcasterna, skicka alternativet -l:

Exempel på datautmatning:

7307 Kör find / -iname "*.c" 2> /dev/null > /tmp/output.txt &
+ 7324 Kör grep -R "hostNamed" / 2> /dev/null > /tmp/grep.txt &

För att endast visa process-ID:n anger du:

Exempel på datautmatning:

Sluta köra kommandon som körs i bakgrunden

För att kraftfullt eller graciöst avsluta en process, använd kommandot kill. Syntaxen är som följer:

döda PID
döda -15 PID
döda -9 PID
killall process-Name-Here
killall -15 process-Name-Here
killall -9 process-Name-Here

Återställer ett program till förgrundsläge i Linux

Linux låter dig inte bara köra program i bakgrunden, utan även återställa dem till normal körning om du vill. Det finns två verktyg för detta: kommandot ( Ett team är en grupp människor som förenas av gemensamma motiv och intressen.) fg och %-operatorn. Principen för deras ansträngning är extremt enkel. fg kräver specificering av jobbnumret som en parameter, och det måste ersättas med % omedelbart efter operatören utan mellanslag.

hitta / -namn .ini 2> ~/resultat.txt &
19090
fg 1
bash: fg: uppgift avslutad
+ Avsluta 1 hitta / -namn .ini 2> ~/results.txt

I huvudsak består operativsystemet av en kärna och en enorm uppsättning program som är designade för att utföra olika uppgifter, underhålla systemet och möta användarens behov. Nästan all interaktion mellan användaren och operativsystemet sker genom program. Därför är det viktigt för nybörjare att förstå hur man kör ett program på Linux, vad som händer under uppstart och vad är startmetoderna.

Innan vi går vidare till att lansera program måste vi först förstå vad ett program är. I Linux skiljer sig program från andra filer endast genom att de har en körbar flagga. Jag har redan skrivit om detta i detalj i artikeln, så jag kommer inte att upprepa det.

Alla program kan delas in i flera typer:

• Binära program- innehåller instruktioner till processorn som är redo att köras, de flesta program är i detta format, de är snabba och exekveras omedelbart av systemet;
• Bytekod program- dessa är inte längre processorinstruktioner, utan instruktioner från en specifik virtuell maskin som kan exekvera dem utan en virtuell maskin, sådana kommandon kan inte köras. Sådana program förbrukar mer resurser, men är också ganska snabba, deras fördel är att de kan köras utan modifiering var som helst de kan arbeta virtuell maskin. Sådana program inkluderar Java-program.
• Skriptprogram- dessa program består av en uppsättning kommandon i klartext som exekveras av en speciell tolk. Sådana program är långsammare, men de är lättare att utveckla och deras kod kan enkelt och snabbt ändras.

Låt oss nu gå vidare till att lansera program.

Kör program i terminalen

Till en början på operationssalar Unix-system och Linux hade inget grafiskt gränssnitt, så program startades med kommandon från terminalen. Nu är detta också möjligt och används ganska aktivt av erfarna användare. Programstartsyntaxen ser ut så här:

/sökväg/till/fil/program alternativ

Parametrar anges endast när de behövs, men skalet måste alltid känna till hela sökvägen till programmet. Allt efter programnamnet och ett mellanslag är parametrar. Du har säkert redan märkt att vi vanligtvis inte anger hela sökvägen när vi kör program. Det skulle bli väldigt långt och obekvämt.

Utvecklarna har kommit på en lösning. En PATH-variabel skapades, som lagrar alla sökvägar till de mappar där programmen vanligtvis finns - /bin, /sbin, /usr/bin, /usr/sbin och så vidare. Du kan se dess innehåll med kommandot:

När du skriver namnet på ett program söker systemet efter en körbar fil med det namnet i alla mappar från PATH och om det hittar den kör det den. Om det inte finns någon sådan fil visas meddelandet "kommandot hittades inte". För att starta ett av systemprogrammen, skriv bara in dess namn körbar fil, Till exempel:

Och du kan skicka parametrar efter ett mellanslag:

När programmet inte finns i dessa kataloger måste du ange hela sökvägen till det:

/usr/local/bin/ls1

Om du vill köra programmet via ubuntu terminal, som finns i den aktuella mappen, kommer situationen att vara något annorlunda. Systemet söker bara i mapparna i PATH-variabeln det söker inte i den aktuella katalogen. Därför, om du skriver namnet på den körbara filen, får du ett felmeddelande. Du måste ange den fullständiga sökvägen, som du kommer ihåg att den kommer att vara./:

Ibland blir det nödvändigt att överföra någon speciell. Till exempel anger variabeln EDITOR vilken textredigerare ska användas som standard. Du kan ange ett variabelnamn och dess värde före kommandonamnet med hjälp av syntaxen:

variabelnamn = värde kommando

Till exempel:

EDITOR=nano visudo

Som standard öppnar detta kommando inställningarna i Vim-redigeraren, men med detta miljöfaktor inställningarna öppnas i nanoredigeraren.

Kör program som en annan användare

Du vet redan hur du kör programmet linux terminal, hur är det med andra användare? I Windows är det ganska vanligt att köra program som administratör så att programmet kan få fler åtkomsträttigheter i systemet. På Linux används sudo-verktyget för detta. Hennes namn kan tydas som s häxa u ser do- ändra användare och kör. Som standard kör verktyget kommandot som root superanvändare:

sudo kommando
sudo whoami

Men med alternativet -u kan du köra programmet som vilken användare som helst som är inloggad på systemet:

kommandot sudo -u användarnamn
sudo -u postgres whoami

Kommandot whoami (vem är jag) visar namnet på den aktuella användaren.

Hur man kör ett program i bakgrunden

Ibland blir det nödvändigt att köra ett långvarigt program i terminalen så att det inte stör det fortsatta arbetet. För att göra detta kan du använda att köra programmet i bakgrunden på Linux:

Program namn &

Till exempel:

dd om=/dev/noll av=~/filantal=100000 &

Systemet kommer att mata ut PID, programmets unika identifierare, som du sedan kan använda för att stänga den:

Hur man kör ett skript på Linux

Vi har redan sagt att program är uppdelade i binära och tolkade. Tidigare har vi bara pratat om binära program. För att köra tolkade program behöver du en tolk direkt sådana program inkluderar de som är skrivna på språk som Java, Python, Perl, Ruby, PHP, NodeJS och många andra. Syntaxen för att starta ett sådant program är annorlunda:

tolk /sökväg/till/fil/program alternativ

Olika tolkar beter sig olika, så det är bättre att omedelbart ange hela sökvägen till programmet. Python plockar vanligtvis upp skript från den aktuella mappen utan att ange hela sökvägen:

python hellowrld.py

Och Java-program måste startas så här:

java -jar program.jar

För tolkade programfiler är körbarhetsflaggan valfri, eftersom de skickas som en parameter till huvudprogrammet. Endast Bash-skript är ett undantag. Du kan köra skriptet med en tolk:

Eller skriv bara sökvägen till skriptet:

Skalet själv bestämmer sina skript genom körbarhetsflaggan och exekverar dem. Om körbarhetsflaggan inte är inställd bör du lägga till den:

sudo chmod u+x ./script.sh

För de flesta tolkade program har därför enkla sh-skript skapats som snabbt kan startas.

Kör Linux-program i ett GUI

Det är mycket bekvämare att köra program via ett grafiskt gränssnitt. Om det är omöjligt att starta konsolprogram på detta sätt, finns det genvägar för alla grafiska verktyg som du kan hitta i systemets huvudmeny:

Alternativt kan du köra programmet från filhanterare, genom att dubbelklicka med musen, men då måste körbarhetsflaggan ställas in för det.

Kör skript i grafiskt gränssnitt. Du kan hitta alla menygenvägar i katalogen /usr/share/applications/. Alla program kan startas genom att dubbelklicka härifrån. Men låt oss se vad som finns i genvägen för att göra detta, öppna den i en textredigerare:

Exec-raden anger bland annat kommandot som körs linux-program när du dubbelklickar på en genväg. Du kan ta en av de befintliga genvägarna och göra din egen utifrån den. Detta är helt enkelt namnet på programmet. Men det är viktigt att notera att det är bättre att ange den fullständiga sökvägen på platser som genvägar, skript, cron och så vidare, detta kommer att minska antalet fel, eftersom du inte kan veta om systemet i detta fall kontrollerar PATH eller letar bara efter programmet i den aktuella katalogen. Nu vet du allt om hur man kör ett program på Linux.

Slutsatser

I den här artikeln tittade vi på hur man kör ett program via Ubuntu-terminalen eller i annat Linux-distributioner. Även om detta verkar vara ett väldigt enkelt ämne, finns det några intressanta punkter som kan vara användbara. Men du vet redan om dem. Om du har några frågor, fråga i kommentarerna!