Oppgaver og prosesser

Ethvert program som kjører på Linux kalles prosess. Linux som multitasking-system er preget av at mange prosesser som tilhører en eller flere brukere kan utføres samtidig. Du kan vise en liste over prosesser som kjører for øyeblikket ved å bruke kommandoen ps, for eksempel som følger:

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

Vær oppmerksom på at kommandoen som standard ps viser bare en liste over de prosessene som tilhører brukeren som startet den. For å se alle prosesser som kjører i systemet, må du gi kommandoen ps -a . Behandle tall(prosess-ID eller PID), oppført i den første kolonnen, er unike numre som systemet tildeler hver prosess som kjører. Den siste kolonnen, med overskriften COMMAND, indikerer navnet på kommandoen som kjøres. I dette tilfellet inneholder listen prosesser lansert av brukeren larry selv. Det er mange andre prosesser som kjører i systemet, de full liste kan vises med kommandoen ps-aux. Men blant kommandoene som kjøres av bruker larry, er det bare bash (kommandoskallet for bruker larry) og selve kommandoen ps. Bash-skallet kan sees kjøres samtidig med kommandoen ps. Når brukeren skrev inn kommandoen ps, begynte bash-skallet å utføre det. Etter laget ps har fullført arbeidet (prosesstabellen vises), går kontrollen tilbake til bash-prosessen. Deretter viser bash-skallet en ledetekst og venter på en ny kommando.

En løpende prosess kalles også oppgave(jobb). Begrepene prosess og oppgave brukes om hverandre. Imidlertid kalles vanligvis en prosess en oppgave når det betyr jobbledelse(jobbkontroll). Jobbkontroll er en kommandoskallfunksjon som gir brukeren muligheten til å bytte mellom flere jobber.

I de fleste tilfeller vil brukere bare kjøre én oppgave - dette vil være den siste kommandoen de skrev inn i kommandoskallet. Imidlertid har mange skjell (inkludert bash og tcsh) funksjoner jobbledelse(jobbkontroll), slik at du kan kjøre flere kommandoer samtidig eller oppgaver(jobber) og, etter behov, veksle mellom dem.

Jobbledelse kan være nyttig hvis du for eksempel skal redigere en stor tekstfil og ønsker å midlertidig avbryte redigeringen for å utføre en annen operasjon. Du kan bruke jobbadministrasjonsfunksjonene til å forlate redigeringsprogrammet midlertidig, gå tilbake til shell-ledeteksten og utføre andre handlinger. Når de er ferdige, kan du gå tilbake til å jobbe med redaktøren og finne den i samme tilstand som den ble igjen. Det er mange flere nyttige bruksområder for jobbadministrasjonsfunksjoner.

Forgrunns- og bakgrunnsmodus

Oppgaver kan være enten forgrunnen(forgrunnen), eller bakgrunn(bakgrunn). Det kan bare være én oppgave i forgrunnen til enhver tid. Forgrunnsoppgaven er oppgaven du samhandler med; den mottar input fra tastaturet og sender utdata til skjermen (med mindre du selvfølgelig har omdirigert input eller output et annet sted). Imot, bakgrunnsjobber ikke motta input fra terminalen; Vanligvis krever ikke slike jobber brukerinteraksjon.

Noen oppgaver tar veldig lang tid å fullføre, og ingenting interessant skjer mens de kjører. Et eksempel på slike oppgaver er kompilering av programmer, samt komprimering av store filer. Det er ingen grunn til å stirre på skjermen og vente på at disse oppgavene skal fullføres. Slike jobber bør kjøres inn bakgrunn. I løpet av denne tiden kan du jobbe med andre programmer.

For å kontrollere utførelsen av prosesser i Linux, er det gitt en overføringsmekanisme signaler. Et signal er prosessens evne til å utveksle standard korte meldinger direkte ved hjelp av systemet. Signalmeldingen inneholder ingen informasjon bortsett fra signalnummeret (for enkelhets skyld kan et navn forhåndsdefinert av systemet brukes i stedet for et nummer). For å overføre et signal trenger en prosess bare å bruke et systemanrop drepe(), og for å motta signalet trenger du ikke noe. Hvis en prosess trenger å svare på et signal på en spesiell måte, kan den registrere seg handler, og hvis det ikke er noen behandler, vil systemet reagere på det. Vanligvis fører dette til at prosessen som mottok signalet avsluttes umiddelbart. Signalbehandleren starter asynkront, umiddelbart etter mottak av signalet, uansett hva prosessen gjør på det tidspunktet.

To signaler - nummer 9 ( DREPE) og 19 ( STOPPE) - alltid behandlet av systemet. Den første av dem er nødvendig for å drepe prosessen sikkert (derav navnet). Signal STOPPE suspenderer prosess: i denne tilstanden fjernes ikke prosessen fra prosesstabellen, men utføres ikke før den mottar signal 18 ( FORTS) - hvoretter det vil fortsette å fungere. I Linux-kommandoskallet, signalet STOPPE kan overføres til den aktive prosessen ved hjelp av en escape-sekvens Ctrl -Z .

Signal nummer 15 ( BEGREP) tjener til å avbryte jobben. På avbrudd(avbryte) jobbprosessen dør. Jobber blir vanligvis avbrutt av en fluktsekvens Ctrl -C. Det er ingen måte å gjenopprette en avbrutt jobb. Du bør også være oppmerksom på at noen programmer fanger opp signalet BEGREP(ved hjelp av en behandler), slik at du trykker på en tastekombinasjon Ctrl -C(o) kan ikke avbryte prosessen umiddelbart. Dette gjøres for at programmet skal kunne ødelegge spor etter arbeidet sitt før det fullføres. I praksis kan noen programmer ikke avbrytes på denne måten i det hele tatt.

Overføre til bakgrunn og ødelegge jobber

La oss begynne med enkelt eksempel. La oss se på ja-kommandoen, som ved første øyekast kan virke ubrukelig. Denne kommandoen sender en endeløs strøm av strenger som består av tegnet y til standard utdata. La oss se hvordan denne kommandoen fungerer:

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

Sekvensen av slike linjer vil fortsette på ubestemt tid. Du kan ødelegge denne prosessen ved å sende den et avbruddssignal, dvs. ved å trykke Ctrl -C. La oss gjøre ting annerledes nå. For å forhindre at denne endeløse sekvensen vises på skjermen, vil vi omdirigere standardutgangen til yes-kommandoen til /dev/null . Som du kanskje vet, fungerer /dev/null-enheten som et "svart hull": all data som sendes til denne enheten går tapt. Ved å bruke denne enheten er det veldig praktisk å bli kvitt for mye utgang fra noen programmer.

/home/larry# yes > /dev/null

Nå vises ingenting på skjermen. Imidlertid returneres heller ikke skallmeldingen. Dette er fordi yes-kommandoen fortsatt kjører og sender meldingene som består av bokstavene y til /dev/null . Du kan også ødelegge denne oppgaven ved å sende den et avbruddssignal.

La oss nå si at du vil at yes-kommandoen skal fortsette å fungere, men også returnere shell-ledeteksten til skjermen slik at du kan jobbe med andre programmer. For å gjøre dette kan du sette ja-kommandoen i bakgrunnen, og den vil fungere der uten å kommunisere med deg.

En måte å sette en prosess i bakgrunnen på er å legge til en & på slutten av kommandoen. Eksempel:

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

Budskapet er Jobbnummer(jobbnummer) for prosessen ja. Kommandoskallet tildeler et jobbnummer til hver jobb den kjører. Siden yes er den eneste kjørbare jobben, tildeles den nummeret 1. Nummeret 164 er identifikasjonsnummeret knyttet til denne prosessen (PID), og dette nummeret er også gitt til prosessen av systemet. Som vi vil se senere, kan en prosess nås ved å spesifisere begge disse tallene.

Så nå har vi en ja-prosess som kjører i bakgrunnen, som kontinuerlig sender en strøm av y-er til /dev/null-enheten. For å finne ut statusen til denne prosessen, må du utføre kommandoen arbeidsplasser, som er en intern kommando i skallet.

/home/larry# jobber + Kjører ja >/dev/null & /home/larry#

Vi ser at dette programmet virkelig fungerer. For å finne ut statusen til en oppgave, kan du også bruke kommandoen ps, som vist ovenfor.

For å overføre et signal til prosessen (oftest er det behov avbryte jobbjobb) verktøyet brukes drepe. Denne kommandoen gis enten et jobbnummer eller en PID som argument. En valgfri parameter er nummeret på signalet som må sendes til prosessen. Som standard sendes signalet BEGREP. I tilfellet ovenfor var jobbnummeret 1, så kommandoen drep %1 vil avbryte jobben. Når en jobb åpnes med nummeret (i stedet for PID), må dette tallet innledes med et prosentsymbol ("%") på kommandolinjen.

La oss nå skrive inn kommandoen arbeidsplasser igjen for å sjekke resultatet av forrige handling:

/home/larry# jobber avsluttet ja >/dev/null

Faktisk er jobben ødelagt, og neste gang du går inn på jobbkommandoen, vil det ikke være informasjon om den på skjermen.

Du kan også drepe en jobb ved å bruke prosessidentifikasjonsnummeret (PID). Dette nummeret, sammen med jobbidentifikasjonsnummeret, angis når jobben starter. I vårt eksempel var PID-verdien 164, så kommandoen drepe 164 ville tilsvare kommandoen drep %1. Når du bruker PID som argument for kill-kommandoen, trenger du ikke skrive inn "%"-tegnet.

Pause og gjenoppta jobber

La oss først starte prosessen med yes-kommandoen i forgrunnen, slik det ble gjort før:

/home/larry# yes > /dev/null

Som før, fordi prosessen kjører i forgrunnen, kommer ikke shell-prompten tilbake til skjermen.

Nå, i stedet for å avbryte oppgaven med en tastekombinasjon Ctrl -C, oppgaven er mulig utsette(suspendere, bokstavelig talt - å suspendere), sender ham et signal STOPPE. For å sette en oppgave på pause, må du trykke på den aktuelle tastekombinasjonen, vanligvis denne Ctrl -Z .

/home/larry# yes > /dev/null Ctrl -Z+ Stoppet yes >/dev/null /home/larry#

Den suspenderte prosessen utføres rett og slett ikke. Den bruker ikke prosessorressurser. En suspendert oppgave kan startes for å kjøre fra samme punkt som om den ikke hadde blitt suspendert.

For å gjenoppta jobben som kjører i forgrunnen, kan du bruke kommandoen fg(fra ordet forgrunn - forgrunn).

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

Kommandoskallet vil igjen vise kommandonavnet slik at brukeren vet hvilken oppgave han er i. dette øyeblikket lansert i forgrunnen. La oss sette denne oppgaven på pause igjen ved å trykke på tastene Ctrl -Z, men denne gangen la oss starte den i bakgrunnen med kommandoen bg(fra ordet bakgrunn - bakgrunn). Dette vil føre til at prosessen kjører som om den hadde blitt kjørt med en kommando med en & på slutten (som ble gjort i forrige avsnitt):

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

Shell-ledeteksten returneres. Nå laget arbeidsplasser må vise at prosessen ja jobber faktisk for øyeblikket; denne prosessen kan drepes med kommandoen drepe, slik det ble gjort før.

Du kan ikke bruke tastatursnarveien til å pause en oppgave som kjører i bakgrunnen Ctrl -Z. Før du setter en jobb på pause, må den bringes i forgrunnen med kommandoen fg og bare da stoppe. Dermed kommandoen fg kan brukes på enten suspenderte jobber eller på en jobb som kjører i bakgrunnen.

Det er stor forskjell på bakgrunnsjobber og suspenderte jobber. En suspendert oppgave fungerer ikke - det brukes ingen penger på den datakraft prosessor. Denne jobben utfører ingen handling. En suspendert oppgave opptar en viss mengde datamaskin-RAM; etter en tid vil kjernen pumpe ut denne delen av minnet til HDD « poste restante" Derimot kjører en bakgrunnsjobb, bruker minne og gjør noen ting du kanskje vil gjøre, men du kan jobbe med andre programmer samtidig.

Jobber som kjører i bakgrunnen kan forsøke å vise litt tekst på skjermen. Dette vil forstyrre arbeidet med andre oppgaver.

/home/larry# ja &

Her har ikke standardutdata blitt omdirigert til /dev/null-enheten, så en endeløs strøm av y-tegn vil bli skrevet ut på skjermen. Denne tråden kan ikke stoppes fordi tastekombinasjonen Ctrl -C påvirker ikke jobber i bakgrunnen. For å stoppe denne utgangen, må du bruke kommandoen fg, som vil bringe oppgaven i forgrunnen, og deretter ødelegge oppgaven med en tastekombinasjon Ctrl -C .

La oss komme med en bemerkning til. Vanligvis etter team fg og teamet bg påvirke de jobbene som sist ble suspendert (disse jobbene vil bli merket med et +-symbol ved siden av jobbnummeret hvis du skriver inn kommandoen arbeidsplasser). Hvis en eller flere jobber kjører samtidig, kan jobber plasseres i forgrunnen eller bakgrunnen ved å spesifisere kommandoer som argumenter fg eller kommandoer bg deres identifikasjonsnummer (jobb-ID). For eksempel kommandoen fg %2 setter jobb nummer 2 foran og kommandoen bg %3 setter jobb nummer 3 i bakgrunnen. Bruk PID-er som kommandoargumenter fg Og bg det er forbudt.

Dessuten, for å bringe en jobb i forgrunnen, kan du ganske enkelt spesifisere nummeret. Ja, laget %2 vil tilsvare kommandoen fg %2 .

Det er viktig å huske at jobbkontrollfunksjonen tilhører skallet. Lag fg , bg Og arbeidsplasser er interne team skjell. Hvis du av en eller annen grunn bruker et kommandoskall som ikke støtter jobbadministrasjonsfunksjoner, vil du ikke finne disse (og lignende) kommandoene i det.

Administrering av en server som kjører Linux er ofte ledsaget av flere manipulasjoner av kommandoer i terminalvinduet. Dette er et kjent bilde for de som administrerer servere på Linux, og i noen tilfeller er det praktisk å kjøre kommandoer i bakgrunnen. Dette kan godt brukes i praksis, og det er verdt å merke seg grunnene til at det kan være nyttig:
— Når terminalen er overbelastet med en haug med meldinger, og det ikke er mulig å utføre tilleggshandlinger parallelt;
— Hvis du lukker terminalen, stopper den gjeldende prosessen og dens underordnede prosesser;
Disse problemene kan løses enkelt; i enkle termer må vi fullstendig skille den kjørende prosessen fra kontrollterminalen.

I dette innlegget skal vi se på Linuxs nyttige evne til å kjøre kommandoer i bakgrunnen. Med andre ord, prosessen du starter vil bli utført separat fra kontrollterminalen.

Hvordan kjøre kommandoer eller prosesser i bakgrunnen
Hvis prosessen kjører i et terminalvindu, kan du sette den på pause ved å bruke kommandoen Ctrl+Z, sikkert mange mennesker vet dette og vil tenke, så hva. Og her er det interessante, etter å ha suspendert prosessen, kan vi fortsette den i bakgrunnen, for å gjøre dette må vi skrive inn kommandoen

Etter å ha skrevet inn denne kommandoen, fortsetter prosessen, men i bakgrunnen. For å se alle prosesser som kjører i bakgrunnen, kan du skrive inn kommandoen

La oss se på et enkelt eksempel på hvordan dette kan brukes. La oss si at vi har en , som vi må pakke ut, men vi har ikke tid til å vente, og vi ønsker å jobbe parallelt.

Pakker ut arkivet i bakgrunnen

$ tar -czf home.tar.gz .

Klikk Cntr+Z, skriv deretter inn kommandoene

$bg$jobber

Den andre måten er å legge til et & på slutten av kommandoen, dette vil fortelle systemet om å kjøre kommandoen i bakgrunnen.

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

Denne metoden lar prosesser kjøre i bakgrunnen, men STDIN, STDOUT, STDERR er fortsatt koblet til terminalen. La oss nå sørge for at prosessen kjører selv når terminalen er stengt.

Utfører en prosess etter å ha lukket terminalvinduet
For å holde prosessen i gang selv etter å ha lukket terminalvinduet, kan vi bruke kommandoen fornekte. Det vil "hekte ut" prosessen fra skallet til terminalvinduet, hvoretter den vil bli utført selv etter at konsollvinduet er lukket.
La oss se på et eksempel på bruk av standardkommandoen rsync, la oss prøve å kjøre den i bakgrunnen og koble fra prosessen fra terminalen.

$ sudo rsync Maler/* /var/www/html/ & $ jobber $ disown -h %1 $ jobber

Du kan også bruke kommandoen nohup, vil det tillate prosessen å fortsette å kjøre selv når brukeren går ut av systemskallet.

$ nohup tar -czf iso.tar.gz Maler/* & $ jobber

Hvordan skille en prosess fra Linux-kontrollterminalen
For å skille prosessen fullstendig fra kontrollterminalen, kan du også bruke en kommando som vil være effektiv når du bruker et grafisk brukergrensesnitt (GUI), for eksempel Firefox-nettleseren.

$firefox/dev/null &

I Linux-system(og på nesten alle Unix-systemer) /dev/null er en spesiell enhetsfil, som også kalles en "nullenhet". Å skrive til den utføres vellykket, uavhengig av mengden informasjon som er registrert; lesing fra den tilsvarer å lese slutten av filen (EOF).

Forrige gang snakket vi om å jobbe med input-, output- og feilstrømmer i bash-skript, filbeskrivelser og stream-omdirigering. Nå vet du allerede nok til å skrive noe eget. På dette stadiet av mestring av bash kan du godt ha spørsmål om hvordan du administrerer kjørende skript og hvordan du automatiserer lanseringen av dem.

Så langt har vi skrevet inn skriptnavn på kommandolinjen og trykket på Enter, noe som får programmene til å kjøre umiddelbart, men dette er ikke tilfelle. den eneste måten kalle skript. I dag skal vi snakke om hvordan et skript kan fungere med Linux-signaler, om ulike tilnærminger til å kjøre skript og administrere dem mens de kjører.

Linux-signaler

I Linux er det mer enn tre dusin signaler som genereres av systemet eller applikasjonene. Her er en liste over de mest brukte, som sikkert vil komme godt med når du utvikler skript kommandolinje.

Signalkode	Navn	Beskrivelse
1	SIGHUP	Å stenge terminalen
2	SIGINT	Signal for å stoppe prosessen av brukeren fra terminalen (CTRL + C)
3	SIGQUIT	Signal for å stoppe en prosess av brukeren fra terminalen (CTRL + \) med en minnedump
9	SIGKILL	Ubetinget avslutning av prosessen
15	SIGTERM	Behandlingsavslutningsforespørselssignal
17	SIGSTOP	Tvinger en prosess til å bli suspendert, men ikke avsluttet
18	SIGTSTP	Setter en prosess på pause fra terminalen (CTRL+Z), men slår ikke av
19	SIGCONT	Fortsett å utføre en tidligere stoppet prosess

Hvis bash-skallet mottar et SIGHUP-signal når du lukker terminalen, går den ut. Før den avsluttes, sender den et SIGHUP-signal til alle prosesser som kjører i den, inkludert kjørende skript.

SIGINT-signalet får driften til å stoppe midlertidig. Linux-kjernen slutter å tildele prosessortid til skallet. Når dette skjer, varsler skallet prosesser ved å sende dem et SIGINT-signal.

Bash-skript kontrollerer ikke disse signalene, men de kan gjenkjenne dem og utføre visse kommandoer for å forberede skriptet for konsekvensene forårsaket av signalene.

Sender signaler til skript

Bash-skallet lar deg sende signaler til skript ved hjelp av hurtigtaster. Dette er veldig nyttig hvis du midlertidig må stoppe et kjørende skript eller avslutte operasjonen.

Avslutte en prosess

Kombinasjon CTRL-taster+C genererer SIGINT-signalet og sender det til alle prosesser som kjører i skallet, og får dem til å avslutte.

La oss kjøre følgende kommando i skallet:

$ søvn 100
Etter det vil vi fullføre arbeidet med tastekombinasjonen CTRL + C.

Avslutt en prosess fra tastaturet

Midlertidig stoppe prosessen

CTRL + Z-tastekombinasjonen genererer SIGTSTP-signalet, som suspenderer prosessen, men ikke avslutter den. En slik prosess forblir i minnet og arbeidet kan gjenopptas. La oss kjøre kommandoen i skallet:

$ søvn 100
Og stopp det midlertidig med tastekombinasjonen CTRL + Z.

Sett prosessen på pause

Tallet i hakeparenteser er jobbnummeret som skallet tildeler prosessen. Skallet behandler prosesser som kjører i det som jobber med unike numre. Den første prosessen er tildelt nummer 1, den andre - 2, og så videre.

Hvis du pauser en jobb som er bundet til et skall og prøver å avslutte den, vil bash utstede en advarsel.

Du kan se suspenderte jobber med følgende kommando:

Ps –l

Liste over gjøremål

I kolonnen S, som viser prosessstatus, vises T for suspenderte prosesser. Dette indikerer at kommandoen enten er suspendert eller i sporingstilstand.

Hvis du trenger å avslutte en suspendert prosess, kan du bruke kill-kommandoen. Du kan lese detaljer om det.

Hennes samtale ser slik ut:

Drep prosessID

Signalavskjæring

For å aktivere Linux-signalsporing i et skript, bruk trap-kommandoen. Hvis skriptet mottar signalet som er spesifisert når denne kommandoen kalles, behandler det det uavhengig, mens skallet ikke vil behandle et slikt signal.

Trappe-kommandoen lar skriptet svare på signaler som ellers ville blitt behandlet av skallet uten dets innblanding.

La oss se på et eksempel som viser hvordan trap-kommandoen spesifiserer koden som skal utføres og en liste over signaler, atskilt med mellomrom, som vi ønsker å avskjære. I dette tilfellet er det bare ett signal:

#!/bin/bash trap "echo " Trapped Ctrl-C"" SIGINT echo Dette er et testskript count=1 mens [ $count -le 10 ] do echo "Loop #$count" sleep 1 count=$(($ telle + 1)) ferdig
Trap-kommandoen brukt i dette eksemplet gir utdata tekstmelding når den oppdager et SIGINT-signal, som kan genereres ved å trykke Ctrl + C på tastaturet.

Signalavskjæring

Hver gang du trykker CTRL + C, utfører skriptet ekkokommandoen som er spesifisert når du kaller sporing i stedet for å la skallet avslutte den.

Du kan avskjære skriptutgangssignalet ved å bruke navnet på EXIT-signalet når du kaller trap-kommandoen:

#!/bin/bash trap "echo Goodbye..." EXIT count=1 mens [ $count -le 5 ] gjør ekko "Loop #$count" sleep 1 count=$(($count + 1)) ferdig

Avskjærer skriptavslutningssignalet

Når skriptet avsluttes, enten normalt eller på grunn av et SIGINT-signal, vil skallet avskjære og utføre ekkokommandoen.

Endring av avlyttede signaler og kansellering av avlytting

For å endre signaler som fanges opp av skriptet, kan du kjøre trap-kommandoen med nye parametere:

#!/bin/bash trap "ekko "Ctrl-C er fanget."" SIGINT count=1 mens [ $count -le 5 ] ekko "Loop #$count" sleep 1 count=$(($count + 1) ) ferdig trap "ekko "Jeg endret fellen!"" SIGINT count=1 mens [ $count -le 5 ] gjør ekko "Second Loop #$count" sleep 1 count=$(($count + 1)) done

Modifikasjon av signalavskjæring

Etter modifikasjon vil signalene bli behandlet på en ny måte.

Signalavskjæring kan også kanselleres ved ganske enkelt å utføre trap-kommandoen, gi den en dobbel strek og signalnavnet:

#!/bin/bash trap "ekko "Ctrl-C er fanget."" SIGINT count=1 mens [ $count -le 5 ] ekko "Loop #$count" sleep 1 count=$(($count + 1) ) ferdig felle -- SIGINT ekko "Jeg har nettopp fjernet fellen" count=1 mens [ $count -le 5 ] gjør ekko "Second Loop #$count" sleep 1 count=$(($count + 1)) done
Hvis skriptet mottar et signal før avlyttingen avbrytes, vil det behandle det som spesifisert i nåværende lag felle. La oss kjøre skriptet:

$ ./myscript
Og trykk CTRL + C på tastaturet.

Signal avlyttet før avlytting ble kansellert.

Det første trykket på CTRL + C skjedde på tidspunktet for skriptutførelse, da signalavskjæring var i kraft, så skriptet utførte ekkokommandoen tildelt signalet. Etter at kjøringen nådde unhook-kommandoen, fungerte CTRL + C-kommandoen som vanlig, og avsluttet skriptet.

Kjører kommandolinjeskript i bakgrunnen

Noen ganger tar bash-skript lang tid å fullføre en oppgave. Det kan imidlertid hende du må kunne jobbe normalt på kommandolinjen uten å vente på at skriptet skal fullføres. Det er ikke så vanskelig å gjennomføre.

Hvis du har sett listen over prosesser som sendes ut av ps-kommandoen, har du kanskje lagt merke til prosesser som kjører i bakgrunnen og ikke er knyttet til en terminal.
La oss skrive følgende manus:

#!/bin/bash count=1 mens [ $count -le 10 ] sover 1 count=$(($count + 1)) ferdig
La oss kjøre den ved å spesifisere og-tegnet (&) etter navnet:

$ ./myscipt &
Dette vil føre til at den kjører som en bakgrunnsprosess.

Kjører et skript i bakgrunnen

Skriptet vil bli lansert i en bakgrunnsprosess, identifikatoren vil vises i terminalen, og når kjøringen er fullført, vil du se en melding om dette.

Merk at selv om skriptet kjører i bakgrunnen, fortsetter det å bruke terminalen til å sende ut meldinger til STDOUT og STDERR, noe som betyr at teksten det sender ut eller feilmeldinger vil være synlig i terminalen.

Liste over prosesser

Med denne tilnærmingen, hvis du går ut av terminalen, vil skriptet som kjører i bakgrunnen også avsluttes.

Hva om du vil at skriptet skal fortsette å kjøre etter at du har stengt terminalen?

Utfører skript som ikke avsluttes når terminalen lukkes

Skript kan kjøres i bakgrunnsprosesser selv etter at terminalsesjonen er avsluttet. For å gjøre dette kan du bruke nohup-kommandoen. Denne kommandoen lar deg kjøre et program ved å blokkere SIGHUP-signaler som sendes til prosessen. Som et resultat vil prosessen bli utført selv når du går ut av terminalen der den ble lansert.

La oss bruke denne teknikken når vi kjører skriptet vårt:

Nohup ./myscript &
Dette er det som sendes ut til terminalen.

Team nohup

Nohup-kommandoen kobler fra en prosess fra terminalen. Dette betyr at prosessen vil miste referanser til STDOUT og STDERR. For ikke å miste dataene fra skriptet, omdirigerer nohup automatisk meldinger som kommer i STDOUT og STDERR til nohup.out-filen.

Merk at hvis du kjører flere skript fra samme katalog, vil utdataene deres ende opp i en enkelt nohup.out-fil.

Se oppgaver

Jobs-kommandoen lar deg se gjeldende jobber som kjører i skallet. La oss skrive følgende manus:

#!/bin/bash count=1 mens [ $count -le 10 ] ekko "Loop #$count" sleep 10 count=$(($count + 1)) ferdig
La oss kjøre det:

$ ./myscript
Og stopp det midlertidig med tastekombinasjonen CTRL + Z.

Kjøre og sette et skript på pause

La oss kjøre det samme skriptet i bakgrunnen, mens vi omdirigerer skriptets utdata til en fil slik at den ikke viser noe på skjermen:

$ ./myscript > outfile &
Ved å nå utføre jobbkommandoen, vil vi se informasjon om både det suspenderte skriptet og det som kjører i bakgrunnen.

Få informasjon om skript

-l-bryteren når du kaller jobbkommandoen indikerer at vi trenger informasjon om prosess-IDer.

Starter suspenderte jobber på nytt

For å starte skriptet på nytt i bakgrunnen, kan du bruke bg-kommandoen.

La oss kjøre skriptet:

$ ./myscript
Trykk CTRL + Z, som midlertidig stopper utførelsen. La oss kjøre følgende kommando:

$bg

bg kommando

Skriptet kjører nå i bakgrunnen.

Hvis du har flere suspenderte jobber, kan du sende jobbnummeret til bg-kommandoen for å starte en bestemt jobb på nytt.

For å starte en jobb på nytt i normal modus bruk fg kommandoen:

Planlegger å kjøre skript

Linux gir et par måter å kjøre bash-skript på et gitt tidspunkt. Dette er at-kommandoen og cron-jobbplanleggeren.

At-kommandoen ser slik ut:

Ved [-f filnavn] tid
Denne kommandoen gjenkjenner mange tidsformater.

• Standard, som indikerer timer og minutter, for eksempel - 10:15.
• Ved å bruke AM/PM-indikatorer, før eller etter middag, for eksempel - 22:15.
• Bruke spesielle navn som nå, middag, midnatt.

I tillegg til å kunne spesifisere tidspunktet en jobb skal kjøres på, kan at-kommandoen også sendes en dato ved å bruke et av de støttede formatene.

• Et standard datoformat der datoen er skrevet med mønstrene MMDDYY, MM/DD/YY eller DD.MM.YY.
• En tekstrepresentasjon av datoen, for eksempel 4. juli eller 25. desember, mens året kan angis, eller du kan klare deg uten.
• Opptak som nå + 25 minutter.
• Opptaksvisning 22:15 i morgen.
• Opptakstype 10:15 + 7 dager.

La oss ikke gå dypere inn i dette emnet, la oss se på en enkel brukssituasjon for kommandoen:

$ ved -f ./myscript nå

Planlegge jobber ved hjelp av at-kommandoen

-M-bryteren når du ringer på brukes til å sende det skriptet sender ut til e-post, hvis systemet er konfigurert tilsvarende. Hvis du sender e-post er ikke mulig, vil denne bryteren ganske enkelt undertrykke utgangen.

For å se listen over jobber som venter på å bli utført, kan du bruke atq-kommandoen:

Liste over ventende oppgaver

Sletter ventende jobber

Kommandoen atrm lar deg slette en ventende jobb. Når du ringer det, oppgi oppgavenummeret:

$atrm 18

Sletting av en jobb

Kjør skript etter en tidsplan

Å planlegge skriptene til å kjøre én gang ved å bruke at-kommandoen kan gjøre livet enklere i mange situasjoner. Men hva om du trenger at skriptet skal kjøres til samme tid hver dag, eller en gang i uken, eller en gang i måneden?

Linux har et crontab-verktøy som lar deg planlegge skript som må kjøres regelmessig.

Crontab kjører i bakgrunnen og kjører, basert på data i såkalte cron-tabeller, planlagte jobber.

For å vise en eksisterende cron-jobbtabell, bruk følgende kommando:

$ crontab –l
Når du planlegger at et skript skal kjøres etter en tidsplan, godtar crontab data om når jobben må utføres i følgende format:

Minutt, time, dag i måneden, måned, ukedag.
For eksempel, hvis du vil at et bestemt skript kalt kommando skal utføres hver dag klokken 10:30, vil dette tilsvare følgende oppføring i oppgavetabellen:

30 10 * * * kommando
Her indikerer jokertegnet "*" som brukes for feltene dag i måned, måned og ukedag at cron skal kjøre kommandoen hver dag i hver måned kl. 10:30.

Hvis du for eksempel vil at skriptet skal kjøre klokken 16:30 hver mandag, må du opprette følgende oppføring i oppgavetabellen:

30 16 * * 1 kommando
Nummereringen av ukedagene starter fra 0, 0 betyr søndag, 6 betyr lørdag. Her er et annet eksempel. Her vil kommandoen bli utført kl. 12.00 den første dagen i hver måned.

00 12 1 * * kommando
Måneder er nummerert fra 1.
For å legge til en oppføring i en tabell, må du ringe crontab med -e-bryteren:

Crontab –e
Deretter kan du angi kommandoer for generering av tidsplan:

30 10 * * * /home/likegeeks/Desktop/myscript
Takket være denne kommandoen blir skriptet kalt opp hver dag kl. 10:30. Hvis du støter på feilen "Ressurs midlertidig utilgjengelig", kjør kommandoen nedenfor som root:

$ rm -f /var/run/crond.pid
Du kan organisere periodisk lansering av skript ved å bruke cron enda enklere ved å bruke flere spesielle kataloger:

/etc/cron.hourly /etc/cron.daily /etc/cron.weekly /etc/cron.monthly
Plassering av en skriptfil i en av dem vil føre til at den kjøres henholdsvis hver time, daglig, ukentlig eller månedlig.

Kjør skript ved pålogging og oppstart av skall

Du kan automatisere lanseringen av skript basert på ulike hendelser, for eksempel brukerinnlogging eller shell-lansering. Du kan lese om filer som behandles i slike situasjoner. Dette er for eksempel følgende filer:

$HOME/.bash_profile $HOME/.bash_login $HOME/.profile
For å kjøre et skript ved pålogging, plasser kallet i .bash_profile-filen.

Hva med å kjøre skript når du åpner en terminal? .bashrc-filen hjelper deg med å organisere dette.

Resultater

I dag diskuterte vi spørsmål knyttet til ledelse Livssyklus skript, vi snakket om hvordan man kjører skript i bakgrunnen, hvordan man planlegger utførelse av dem. Neste gang, les om funksjoner i bash-skript og bibliotekutvikling.

Kjære lesere! Bruker du verktøy for å planlegge at kommandolinjeskript skal kjøres etter en tidsplan? Hvis ja, fortell oss om dem.

Linux-terminaltjenesten kjører som standard i enkeltoppgavemodus. Dette betyr at ethvert mannskap som blir lansert sperrer terminalen til den er ferdigstilt. Denne tilnærmingen er ikke praktisk når du kjører programmer som krever lang utførelsestid. Dette problemet kan løses på to måter: åpne et ekstra terminalvindu og utfør en annen kommando i det, eller bruk bakgrunnsmodus. Alle gjeldende operativsystemer, inkludert Linux, er multitasking, som betyr muligheten til å kjøre flere programmer samtidig.

Hvordan kan jeg kjøre en brigade i bakgrunnen slik at jeg umiddelbart får tilgang til kommandolinjegrensesnittet? Et mannskap som har blitt tvunget til å løpe kalles en bakgrunnsprosess. Bakgrunnsprosesser vises ikke på skjermen. For eksempel kjører Apache HTTPD-serveren i bakgrunnen for å betjene nettsider. Du kan sette et skallskript eller en hvilken som helst kommando i lavprioritetsmodus. En oppgave (for eksempel et mannskap eller et skript) kan settes i bakgrunnen ved å legge til et "&" på slutten av kommandolinjen. Denne setningen setter kommandoen i bakgrunnen og frigjør plass i terminalen. Et team som løper i bakgrunnen kalles en jobb. Mens bakgrunnskommandoen kjører, er det mulig å utføre andre kommandoer. Syntaksen er som følger:

kommando & skriptnavn & /bane/til/kommando arg1 arg2 & kommando-1 | kommando-2 arg1 & kommando-1 | kommando-2 -arg1 -arg2 >/bane/til/utdata &

For å kjøre programmer i bakgrunnen uten å blokkere terminalvinduet, må du bruke den spesielle "&"-instruktøren. Plasser dette tegnet helt på slutten av linjen etter å ha spesifisert kommandonavn, alternativer og inndataparametere. I generelt syn denne sekvensen kan angis som "kommandonavn -alternativ input_parameter &".

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

Etter å ha trykket på Enter-knappen vil programmet automatisk starte i bakgrunnen. I dette tilfellet vil terminalen vise en linje med følgende innhold "[oppgavenummer] prosessidentifikator" og vil be deg om å skrive inn en nyopprettet kommando.

Finn kommandoer som kjører i bakgrunnen i Linux

Kjør følgende kommando:

Eksempel på datautgang:

Kjører find / -iname "*.c" 2> /dev/null > /tmp/output.txt &
+ Kjører grep -R "hostNamed" / 2> /dev/null > /tmp/grep.txt &

Hvor er ordreidentifikatorene.

For å vise prosess-ID-er for jobb-ID-er i tillegg til standardkastene, passerer du alternativet -l:

Eksempel på datautgang:

7307 Kjører find / -iname "*.c" 2> /dev/null > /tmp/output.txt &
+ 7324 Kjører grep -R "hostNamed" / 2> /dev/null > /tmp/grep.txt &

For å vise bare prosess-ID-er, skriv inn:

Eksempel på datautgang:

Slutt å utføre kommandoer som kjører i bakgrunnen

For å med kraft eller elegant avslutte en prosess, bruk kill-kommandoen. Syntaksen er som følger:

drepe PID
drepe -15 PID
drep -9 PID
killall prosess-navn-her
killall -15 prosess-navn-her
killall -9 prosess-navn-her

Returnerer et program til forgrunnsmodus i Linux

Linux lar deg ikke bare kjøre programmer i bakgrunnen, men også returnere dem til normal kjøring hvis du ønsker det. Det er to verktøy for dette: kommandoen ( Et team er en gruppe mennesker forent av felles motiver og interesser.) fg og %-operatoren. Prinsippet for deres innsats er ekstremt enkelt. fg krever spesifikasjon av jobbnummeret som en parameter, og det må erstattes med % umiddelbart etter operatøren uten mellomrom.

finn / -navn .ini 2> ~/resultater.txt &
19090
fg 1
bash: fg: oppgave avsluttet
+ Avslutt 1 finn / -navn .ini 2> ~/resultater.txt

Operativsystemet består i hovedsak av en kjerne og et stort sett med programmer som er designet for å utføre ulike oppgaver, vedlikeholde systemet og møte brukerens behov. Nesten all interaksjon mellom brukeren og operativsystemet skjer gjennom programmer. Derfor er det viktig for nybegynnere å forstå hvordan man kjører et program på Linux, hva som skjer under oppstart og hva som er lanseringsmetodene.

Før vi går videre til å lansere programmer, må vi først forstå hva et program er. I Linux skiller programmer seg fra andre filer bare ved at de har et kjørbart flaggsett. Jeg har allerede skrevet om dette i detalj i artikkelen, så jeg vil ikke gjenta det.

Alle programmer kan deles inn i flere typer:

• Binære programmer- inneholder instruksjoner til prosessoren som er klare for kjøring, de fleste programmer er i dette formatet, de er raske og kjøres umiddelbart av systemet;
• Bytekode programmer- Dette er ikke lenger prosessorinstruksjoner, men instruksjoner fra en spesifikk virtuell maskin som kan utføre dem; uten en virtuell maskin kan ikke slike kommandoer utføres. Slike programmer bruker mer ressurser, men er også ganske raske, deres fordel er at de kan kjøres uten endringer hvor som helst de kan fungere virtuell maskin. Slike programmer inkluderer Java-programmer.
• Skriptprogrammer- disse programmene består av et sett med kommandoer i ren tekst som utføres av en spesiell tolk. Slike programmer er tregere, men de er lettere å utvikle og koden deres kan enkelt og raskt endres.

La oss nå gå videre til å lansere programmer.

Kjøre programmer i terminalen

I første omgang på operasjonsstuer Unix-systemer og Linux hadde ikke et grafisk grensesnitt, så programmer ble lansert ved hjelp av kommandoer fra terminalen. Nå er dette også mulig og brukes ganske aktivt av erfarne brukere. Programstartsyntaksen ser slik ut:

/bane/til/fil/program alternativer

Parametre spesifiseres bare når de er nødvendige, men skallet må alltid kjenne hele banen til programmet. Alt etter programnavnet og et mellomrom er parametere. Du har sikkert allerede lagt merke til at vi vanligvis ikke spesifiserer hele banen når vi kjører programmer. Det ville vært veldig langt og upraktisk.

Utviklerne har kommet med en løsning. En PATH-variabel ble opprettet, som lagrer alle banene til mappene der programmer vanligvis er plassert - /bin, /sbin, /usr/bin, /usr/sbin og så videre. Du kan se innholdet med kommandoen:

Når du skriver inn navnet på et program, søker systemet etter en kjørbar fil med det navnet i alle mappene fra PATH, og hvis det finner det, kjører det det. Hvis det ikke finnes en slik fil, vises meldingen "kommando ikke funnet". For å starte et av systemprogrammene, skriv inn navnet kjørbar fil, For eksempel:

Og du kan sende parametere etter et mellomrom:

Når programmet ikke er i disse katalogene, må du spesifisere hele banen til det:

/usr/local/bin/ls1

Hvis du ønsker å kjøre programmet via ubuntu terminal, som ligger i gjeldende mappe, vil situasjonen være litt annerledes. Systemet søker bare i mappene i PATH-variabelen; det søker ikke i gjeldende katalog. Derfor, hvis du skriver inn navnet på den kjørbare filen, vil du få en feilmelding. Du må spesifisere hele banen, slik du husker den vil være./:

Noen ganger blir det nødvendig å overføre noen spesielle. For eksempel indikerer EDITOR-variabelen hvilken tekstredigerer skal brukes som standard. Du kan spesifisere et variabelnavn og verdien før kommandonavnet ved å bruke syntaksen:

variabel_navn = verdi kommando

For eksempel:

EDITOR=nano visudo

Som standard åpner denne kommandoen innstillingene i Vim-editoren, men med dette miljøvariabel innstillingene åpnes i nano-editoren.

Kjøre programmer som en annen bruker

Du vet allerede hvordan du kjører programmet inn linux terminal, hva med andre brukere? I Windows er det ganske vanlig å kjøre programmer som administrator slik at programmet kan få flere tilgangsrettigheter i systemet. På Linux brukes sudo-verktøyet til dette. Navnet hennes kan tydes som s heks u ser gjøre- endre bruker og utfør. Som standard kjører verktøyet kommandoen som root-superbruker:

sudo kommando
sudo whoami

Men ved å bruke -u-alternativet kan du kjøre programmet som enhver bruker som er logget på systemet:

sudo -u brukernavn kommando
sudo -u postgres whoami

Whoami (hvem er jeg) kommandoen viser navnet på gjeldende bruker.

Hvordan kjøre et program i bakgrunnen

Noen ganger blir det nødvendig å kjøre et langvarig program i terminalen slik at det ikke forstyrrer videre arbeid. For å gjøre dette kan du bruke å kjøre programmet i bakgrunnen på Linux:

programnavn &

For eksempel:

dd if=/dev/null av=~/filantall=100000 &

Systemet vil sende ut PID, programmets unike identifikator, som du deretter kan bruke til å lukke den:

Hvordan kjøre et skript på Linux

Vi har allerede sagt at programmer er delt inn i binære og tolkede. Tidligere snakket vi kun om binære programmer. For å kjøre tolkede programmer trenger du en tolk direkte; slike programmer inkluderer de som er skrevet på språk som Java, Python, Perl, Ruby, PHP, NodeJS og mange andre. Syntaksen for å starte et slikt program er annerledes:

tolk /bane/til/fil/program alternativer

Ulike tolker oppfører seg forskjellig, så det er bedre å spesifisere hele banen til programmet umiddelbart. Python plukker vanligvis opp skript fra gjeldende mappe uten å spesifisere hele banen:

python hellowrld.py

Og Java-programmer må startes slik:

java -jar program.jar

For tolkede programfiler er kjørbarhetsflagget valgfritt, siden de sendes som en parameter til hovedprogrammet. Bare Bash-skript er et unntak. Du kan kjøre skriptet med en tolk:

Eller bare skriv inn banen til skriptet:

Skallet selv bestemmer skriptene ved kjørbarhetsflagget og kjører dem. Hvis kjørbarhetsflagget ikke er satt, bør du legge det til:

sudo chmod u+x ./script.sh

For de fleste tolkede programmer er det derfor laget enkle sh-skript som raskt kan startes.

Kjører Linux-programmer i en GUI

Det er mye mer praktisk å kjøre programmer gjennom et grafisk grensesnitt. Hvis det er umulig å starte konsollprogrammer på denne måten, er det snarveier for alle grafiske verktøy som du finner i hovedmenyen til systemet:

Alternativt kan du kjøre programmet fra filbehandler, ved å dobbeltklikke med musen, men da må kjørbarhetsflagget settes for det.

Kjører skript inn grafisk grensesnitt. Du finner alle meny-snarveiene i katalogen /usr/share/applications/. Ethvert program kan startes ved å dobbeltklikke herfra. Men la oss se hva som er inne i snarveien; for å gjøre dette, åpne den i et tekstredigeringsprogram:

Blant annet spesifiserer Exec-linjen kommandoen som kjører linux-programmer når du dobbeltklikker på en snarvei. Du kan ta en av de eksisterende snarveiene og lage din egen basert på den. Dette er bare navnet på programmet. Men det er viktig å merke seg at det er bedre å spesifisere hele banen på steder som snarveier, skript, cron og så videre, dette vil redusere antall feil, siden du ikke kan vite om systemet i dette tilfellet sjekker PATH eller ser etter programmet bare i gjeldende katalog. Nå vet du alt om hvordan du kjører et program på Linux.

konklusjoner

I denne artikkelen så vi på hvordan du kjører et program gjennom ubuntu-terminalen eller i andre Linux-distribusjoner. Selv om dette virker som et veldig enkelt emne, er det noen interessante punkter som kan være nyttige. Men du vet allerede om dem. Hvis du har spørsmål, spør i kommentarene!