Hur man visar och kör Linux -bakgrundsprocesser

Utförandet av processer är avgörande för alla operativsystem som används eftersom de säkerställer att både applikationerna och andra delar av operativsystemet kan fungera på rätt sätt både i kompatibilitet och i utförandet av deras funktioner.

Varje operativsystem kan hantera processer annorlunda, men för Linux är processer som regel associerade med en terminal. Det betyder att den måste vara öppen så att processen kan fungera normalt, men denna åtgärd kan leda till situationer som:

• Den öppna terminalen kan innehålla mycket utdata eller fel- / diagnosmeddelanden vilket gör det svårt att inte bara läsa data utan att hantera den.

• Om vi ​​skulle stänga terminalen kommer processen tillsammans med dess sekundära processer att sluta direkt påverka den uppgif.webpt som ska utföras.

I denna typ av scenario är det viktigt att utföra de nödvändiga processerna i bakgrunden, en bakgrundsprocess är den process som kommer att utföras på ett dolt sätt och för dess funktion krävs inte användarens ingripande, på detta sätt, även om terminalen är stängd huvud, kommer processen att fortsätta att utföra sin uppgif.webpt. Bakgrundsprocesser gäller för de uppgif.webpter som kan ta tid, till exempel skript, nedladdningsfiler och andra, där vi inte kan vänta på att åtgärden ska slutföras utan att göra något.

I linux kan vi köra processer i förgrunden eller i bakgrunden. Ett program i förgrunden när det körs i terminalen kommer vi inte att kunna utföra något annat kommando förrän processen slutar, men det kan göras från bakgrunden eller bakgrunden.

Ett program som körs i bakgrunden när det väl startat använder inte terminalen från den kördes till slutet. För att köra en programvara eller ett kommando i bakgrunden från terminalen lägger vi till. Om vi ​​lägger till ett ampersand (&) i slutet av kommandot eller skriptet som vi vill köra, körs det i bakgrunden av operativsystemet. Exempel:

 nano & 

Solvetic kommer att förklara hur vi kan se och köra bakgrundsprocesser på Linux.

1. Se lista över processer med ps -kommando i Linux

Med kommandot ps -kommandot kan vi veta status för en process. Ps är processstatus eller processstatus. Kommandot ps listar inte processerna och specificerar vissa PID-, TTY-, TIME- och CMD -kolumner.

PID (processnummer)Varje process får ett unikt identifieringsnummer som tilldelas av Linux -kärnan.

TTYär terminalen associerad med processen, kan den också vara en annan inmatningsenhet.

TIDDen tid som processen har körts.

CMDDet är namnet på kommandot som körs, bash är skalprocessen.

Till exempel, med kommandot ps -A visar det oss alla processer som körs.

2. Starta en bakgrundsprocess eller ett kommando på Linux med bg på Linux

Kommandot bg har utvecklats som ett jobbkontrollkommando som återupptar avbrutna jobb, men kör dem i bakgrunden.

Steg 1
Den grundläggande syntaxen för detta kommando är följande:

 bg [arbete] 

Steg 2
Om en process redan körs måste vi trycka på följande tangenter för att stoppa den och sedan ange kommandot bg för att fortsätta körningen i bakgrunden som ett jobb. För detta exempel kommer vi att använda följande rader:

Ctrl + Z

 tjära -czf hem.tar.gz. (körprocess som stoppas med Ctrl + Z) bg (körning av kommandot i bakgrunden) jobb (visualisering av utförda jobb)

Steg 3
Vi kan se att processen fortfarande körs, men nu i bakgrunden. Det kommer också att vara möjligt att köra en process direkt i bakgrunden genom att ange ampersand i slutet av den:

 tjära -czf hem.tar.gz. & Jobb 

3. Spara att köra Linux -processer efter att ha avslutat terminalen i Linux

Detta är en viktig punkt eftersom, som vi har nämnt, i normalt läge när terminalen är stängd kommer alla aktiva processer att sluta, så att det är möjligt att låta dem fortsätta att köra även när terminalen är stängd.

För detta ändamål kan vi använda kommandot disown som kommer att användas efter att en process har startat och har satts i bakgrunden, kommandot disown är ett skaljobb vars uppgif.webpt är att eliminera jobben från den aktiva listan över det aktiva Shell.

Steg 1
Med avkörningen, när vi stänger terminalen, kommer jobbet inte att krascha eller skicka en SIGHUP till något barnjobb. Dess grundläggande syntax är:

 avvisa jobID 

Steg 2
För dess drift kommer vi att utföra följande:

 sudo rsync Mallar / * / var / www / html / files / & (kommando för att utföra) jobb (aktiva jobb) avvisa -h% 1 (för att inte stänga processen eller kommandot) jobb (visning av jobb)

NoteraOm vi ​​utför mer än en process eller ett kommando kan vi se att var och en av dem får ett identifikations -ID, detta måste anges med avvisning för att ange vilken process som ska fortsätta att köras.

Steg 3
Alternativen att använda med avslag är:

-tillTar bort alla jobb om jobb -ID inte tillhandahålls.

-hMärker varje jobb -ID så att SIGHUP inte skickas till jobbet om skalet får en SIGHUP.

-rRensar bara löpande jobb.

4. Spara att köra Linux -processer efter att ha avslutat terminalen i Linux

Den grundläggande uppgif.webpten för nohup -kommandot är att förhindra att kommandot avbryts automatiskt när du loggar ut eller lämnar skalet. När du använder nohup (no hangup) -kommandot, fångas upp signalen (HUP), som skickas till en process för att informera den om att användaren har loggat ut, av nohup för att processen ska kunna fortsätta köra på några sekunder.

Steg 1
Användningssyntaxen är följande:

 nohup-kommando [kommando-argument …] 

Steg 2
I det här fallet kommer vi att använda följande exempel. Om standardingången är en terminal omdirigerar nohup den från / dev / null. Därför är terminalinmatning inte möjlig när du kör ett kommando med nohup. Om standardutmatningen är en terminal läggs kommandoutmatningen till filen nohup.out eller $ HOME / nohup.out. Om standardfelet är en terminal omdirigeras det till standardutmatning. För att spara utdata till en fil måste vi använda "nohup -kommando> fil".

 nohup tar -czf iso.tar.gz Mallar / * och jobb

5. Koppla bort en Linux -process i terminalen

Steg 1
Om målet är att helt separera en process från terminalen, bör vi använda följande syntax:

 app / dev / null & 

Steg 2
Till exempel:

 firefox / dev / null & 

6. Använd bakgrundsprocesser med Screen på Linux

Om du använder ett kommando i bakgrunden, med alternativen nohup och &), kommer det att köras även efter avslutad session, problemet är att när vi återansluter till samma session igen kommer vi inte att se det aktiva jobbet i bakgrunden, för att korrigera detta finns skärmkommandot.

skärmen är en fönsterhanterare i helskärm som hanterar en fysisk terminal mellan flera processer, normalt är skalen interaktiva. Varje virtuell terminal erbjuder funktionerna för en DEC VT100 -terminal och dessutom flera kontrollfunktioner enligt ISO 6429 (ECMA 48, ANSI X3.64) och ISO 2022 -standarder som gör den extremt dynamisk.

När vi kör skärmen skapas ett enda fönster med ett skal eller det angivna kommandot och förbikopplas sedan för att kunna använda programmet normalt.

Steg 1
För att installera skärmen i Linux kommer vi att utföra följande. Där anger vi bokstaven S för att bekräfta nedladdningen och installationen.

 sudo apt installera skärmen

Steg 2
Efter installationen kör vi kommandot "skärm" och vi kommer att se följande:

Steg 3
Där trycker vi på Enter -tangenten för att omdirigeras till det nya fönstret där vi kör processen eller kommandot som ska användas i bakgrunden:

 sudo tar czf temp.tar.gz / tmp & 

Steg 4
Vi kommer att kunna visualisera de aktiva fönstren med. För att avsluta skärmsessionen kan vi använda knapparna

Ctrl + a + d

Ctrl + alt + d

 skärm -ls 

7. Stoppa eller döda en avstängd eller bakgrundsprocess på Linux

För denna åtgärd, som består i att avsluta körningen av processen i bakgrunden, kan vi använda kommandot "kill" och istället för PID kan vi ange jobbidentifieraren, till exempel:

 jobb (lista aktuella jobb) döda% 2 (döda eller avsluta processen identifieras som 2)

8. Stoppa en process eller ta en process till bakgrunden

Vissa program tar lång tid att slutföra, och de gör inget viktigt under tiden. Att sammanställa program är en av dessa uppgif.webpter, liksom att komprimera en stor fil. Det är ingen idé att sluta använda datorn medan dessa processer avslutar och förbrukar resurser. I dessa fall är det bättre att köra dem i bakgrunden, att lämna datorn i en position för att köra ett annat program.

Processer kan avbrytas. En avstängd process är en som inte körs för tillfället, men som stoppas tillfälligt. När du har avbrutit en uppgif.webpt kan du instruera uppgif.webpten att fortsätta, i förgrunden eller sekunden, efter behov. Att återuppta en avstängd uppgif.webpt ändrar inte alls uppgif.webptens status eftersom den kommer att fortsätta att köra precis där den slutade.

Steg 1
För att avbryta en process används följande kombination, när du trycker på denna kombination dör processen och alla resurser släpps.

Ctrl + C

Steg 2
Låt oss försöka skicka ett upprepande kommando till bakgrunden. Ja -kommandot används för att testa skript som kräver många bekräftelser. Vad det gör är att upprepa "och" med det som är skrivet framför det oändligt tills skriptet stoppas eller användaren stoppar det:

• Om vi ​​skriver "ja" i terminalen så ser vi en oändlig lista över "och".

• Om vi ​​skriver ja hej i terminalen och vi kommer att se en oändlig lista med hej

Steg 3
För att radera en fil utan att trycka på någon knapp när den ber om bekräftelse kan vi använda

 ja | rm -i * .txt 

Steg 4
För att skicka en process till bakgrunden kallar vi den från kommandoraden följt av & skapar oändliga null -enheter

 ja> / dev / null & 

Steg 5
Detta visar oss uppgif.webptsnumret och pid [1] 4106. Om vi ​​nu använder jobbkommandot ser vi

 [1] + Kör ja> / dev / null &

Steg 6
för att ta det till förgrunden skriver vi fg 1 och för att döda processen dödar 4106 som är pid.

 Fg 1 Döda 4106

Med något av de angivna alternativen kommer det att vara möjligt att hantera bakgrundsprocesserna i Linux på ett mycket mer centralt sätt och på så sätt låta de nödvändiga uppgif.webpterna utföras även när sessionen stängs.