10.2.1. Process ID och ursprung Två av de mest grundläggande attributen är process ID, eller pid, och ID för dess överordnade process. Pid är ett positivt heltal som unikt identifierar

10.2.3. Filsystem-uid I mycket speciella fall kan ett program behöva behålla sina root-privilegier för allt utom filsystemåtkomst, för vilket det använder användarens uid. Ursprungligen använd i Linux NFS rymdserver

Domän-ID När du skapar en domän i en databas måste du ange ett domän-ID som är globalt unikt i databasen. Utvecklare använder ofta ett prefix eller suffix på domänidentifierare för att förbättra dokumentationen. Till exempel: SKAPA

Parent Process ID (PPID) Identifieraren för processen som skapade detta

Med process menar vi en kopia av programmet som körs på systemet. Om du till exempel har tre kalkylatorfönster öppna (t.ex. gcalctool), betyder det att du har tre processer igång.

Hitta PID för en hängd process

Varje process i Linux har sin egen identifierare som kallas PID. Innan du stoppar en process måste du bestämma dess PID. För att göra detta kommer vi att använda kommandona ps och grep. ps kommandoär utformad för att visa en lista över aktiva processer i systemet och information om dem. grep kommando körs samtidigt med ps (i en kanal) och kommer att söka efter resultatet av kommandot ps. Du kan lista alla processer genom att köra på kommandoraden:

Men som regel är listan väldigt stor och att hitta processen som vi vill "döda" är inte så lätt. Det är här grep-kommandot kommer till undsättning. Till exempel, för att hitta information om en process som heter gcalctool, kör kommandot:

Ps axu | grep gcalctool

Kommandot grep kommer att söka efter resultatet av kommandot ps och endast de rader som innehåller strängen (ordet) gcalctool kommer att skrivas ut. Det finns en intressant detalj här, till exempel om du inte har gcalctool-applikationen igång, sedan efter exekvering p.s. | grep gcalctool Du kommer få:

$ ps axu | grep gcalctool yuriy 25587 0,0 0,0 10636 884 pts/2 S+ 10:20 0:00 grep --color=auto gcalctool

Det vill säga, vi fick själva grep-processen, eftersom vi angav ordet gcalctool som en parameter för kommandot, och grep befann sig i kommandoutgången ps.

Om gcalctool-processen körs får vi:

Yuriy@yuriy-NIX:~$ ps axu | grep gcalctool yuriy 25609 7.6 0.4 500840 17964 ? Sl 10:20 0:00 gcalctool yuriy 25624 0,0 0,0 10640 884 pts/2 S+ 10:21 0:00 grep --color=auto gcalctool

Här är vi intresserade av raden: " yuriy 25609 7,6 0,4 500840 17964 ? Sl 10:20 0:00 gcalctool" Numret 25609 är PID för gcalctool-processen.

Det finns ett annat enklare sätt att ta reda på PID för en process - detta pidof kommando, som tar processnamnet som en parameter och matar ut dess PID. Ett exempel på att utföra kommandot pidof:

$pidof gcalctool 25609

Vi "dödar" processen med kommandot kill

När PID för en process är känd kan vi döda den döda kommandot. Kill-kommandot tar PID för processen som en parameter. Låt oss till exempel döda processnummer 25609:

Döda 25609

I allmänhet är kommandot kill avsett att skicka en signal till en process. Som standard, om vi inte anger vilken signal som ska skickas, skickas SIGTERM-signalen (från ordet avslutning). SIGTERM säger till att processen ska avslutas. Varje signal har sitt eget nummer. SIGTERM är numrerad 15. En lista över alla signaler (och deras nummer) som kill-kommandot kan skicka kan erhållas genom att köra döda -l. För att skicka SIGKILL-signalen (numrerad 9) till process 25609, kör på kommandoraden:

Döda -9 25609

SIGTERM-signalen kanske inte stoppar processen (till exempel om signalen fångas upp eller blockeras), men SIGKILL dödar alltid processen, eftersom den inte kan fångas upp eller ignoreras.

Vi dödar processer med kommandot killall

killall kommando i Linux är utformad för att "döda" alla processer som har samma namn. Detta är bekvämt eftersom vi inte behöver veta PID för processen. Till exempel vill vi stänga alla processer som heter gcalctool. Kör i terminal:

Killall gcalctool

Killall-kommandot, som kill, skickar SIGTERM-signalen som standard. För att skicka en annan signal måste du använda alternativet -s. Till exempel:

Killall -s 9 gcalctool

Slutsats

Vissa processer kan inte stoppas av en normal användare. Till exempel, om processen startades som root eller som en annan användare på systemet, måste kill- och killall-kommandona köras som superanvändare, lägga till sudo (på Ubuntu):

Sudo döda 123

Det finns situationer när du arbetar i ett GUI (som GNOME) och du inte kan öppna en terminalemulator för att stoppa den hängde processen. Sedan kan du byta till den virtuella konsolen med hjälp av knapparna Ctrl+Alt+F1, logga in på den och kör kommandon därifrån. Och gå sedan tillbaka genom att klicka Ctrl+Alt+F7.

Hjälp med att använda valfritt kommando kan erhållas med kommandot man:

Man ps man grep man pidof man kill man killall

Vi kommer att visa dig hur du dödar en process i Linux. En av de främsta fördelarna med Linux är möjligheten att avsluta en process utan att behöva starta om servern. I den här artikeln kommer vi att visa dig hur du dödar en process i Linux med kommandot kill, pkill och killall.

1. Vad är PID

Innan vi börjar måste vi veta vad ett Process ID (PID) är.

PID representerar den digitala identifieringen av en process i . Varje process har ett unikt PID. Faktum är att till exempel den första processen som startar på ett Linux-baserat system är en process och dess PID är satt till 1. Denna process är föräldern till alla andra processer. Init-processen kan inte dödas med kill-kommandon, och detta säkerställer att den inte kommer att dödas av misstag.

Nu, för att hitta PID för varje pågående process på servern, kan vi köra följande kommando:

Detta ger oss en lista över alla pågående processer och deras motsvarande PID.

Om vi ​​vill hitta PID för en specifik process kan vi använda kommandot pidof följt av processnamnet. Till exempel, för att ta reda på PID för vår MySQL-process, kan du köra följande kommando:

Pidof mysql

För ännu mer detaljerad information kan vi använda kommandot ps aux tillsammans med grep:

PS aux | grep mysql

Nu när vi vet vad ett PID är och hur man hittar PID för en specifik process, kan vi gå vidare till nästa avsnitt och lära oss hur man dödar det.

2. Döda en process med kommandot kill i Linux

Det finns några viktiga regler som vi behöver känna till innan vi börjar använda kommandot kill.

• Du kan bara döda inbyggda processer som hör till ditt användar-ID
• Du kan inte döda andra användares processer
• Du kan inte döda systemprocesser (såvida du inte är superanvändare)
• Rotanvändaren kan döda alla andra användares processer och alla systemprocesser

När vi dödar en process med kommandot kill, skickar vi faktiskt den specifika PID-signal som vi vill döda. Följande signaler används av kill-kommandot:

1 = Lägg på 9 = Döda 15 = Avsluta

Den pålagda signalen används sällan. Oftast använder vi dödsignalen, och om den inte fungerar kan vi använda Avsluta-signalen.

Så när vi väl hittar PID för processen vi vill döda, använd en av metoderna vi beskrev tidigare, vi kan använda kommandot döda -9 PID för att döda processen från den specifika PID.

Till exempel, om PID är 6738, kan vi använda följande kommando:

Döda -9 6738

3. Döda en process med kommandot pkill i Linux

Om du vill använda processnamnet istället för dess PID för att döda det, kan du använda kommandot pkill. Till exempel, om processen vi vill döda kallas , då kan vi använda följande kommando för att döda den:

Pkill mysql

4. Döda en process med kommandot killall i Linux

De två föregående kommandona används för att döda endast en specifik process. Men om vi vill döda en process tillsammans med alla dess underordnade processer kan vi använda kommandot döda alla:

Killall mysql

I det här exemplet kommer vi att döda MySQL-processen och alla dess underordnade processer.

De är de vanligaste exemplen på processdödande i Linux.

I grund och botten tittar vi på PID för att döda programmet som inte svarar och det liknar Windows Task Manager.

Linux GUI erbjuder också samma funktion, men CLI är ett effektivt sätt att utföra dödningsoperationen.

Vad är Process ID PID?

PID står för processidentifieringsnummer, som vanligtvis används av de flesta operativsystemkärnor som Linux, Unix, macOS och Windows.

Detta är ett unikt identifikationsnummer som automatiskt tilldelas varje process när den skapas i operativsystemet.

En process är en körbar instans av ett program.

Varje gång kommer process-ID:t att ta emot ändringar av alla processer utom init, eftersom init alltid är den första processen i systemet och är förfadern till alla andra processer. Detta PID är 1.

Det förinställda maximala PID-värdet är 32 768.

# cat/proc/sys/kernel/pid_max

På 32-bitars system är 32768 maxvärdet, men vi kan ställa in vilket värde som helst upp till 2^22 (ungefär 4 miljoner) på 64-bitars system.

Du kanske frågar varför vi behöver så många PID? eftersom vi inte kan återanvända PID direkt. Också för att undvika eventuella misstag.

PID för att köra processer i systemet kan hittas med följande nio metoder såsom pidof-kommando, pgrep-kommando, ps-kommando, pstree-kommando, ss-kommando, netstat-kommando, lsof-kommando, fuser-kommando och systemctl-kommando.

• pidof: pidof - hitta process-ID för ett pågående program.
• pgrep: pgre - Sök eller bearbeta signaler baserat på namn och andra attribut.
• ps: ps - rapporterar en ögonblicksbild av aktuella processer.
• pstree: pstree - visar ett träd med processer.
• ss: ss används för att visa socketstatistik.
• netstat: netstat visar en lista över öppna uttag.
• lsof: lsof - lista över öppna filer.
• fuser: process-ID:n i en termlista över alla processer som öppnar en eller flera filer
• systemctl: systemctl - Hantera systemd system och service manager

I den här handledningen kommer vi att titta på Apache-process-ID för verifiering.

Metod-1: Använd pidof-kommandot

pidof används för att hitta process-ID för ett program som körs.

Den skriver ut dessa identifierare till standardutdata.

För att demonstrera detta kommer vi att ta reda på process-ID för Apache2 från ett Debian 9-system.

# pidof apache2 3754 2594 2365 2364 2363 2362 2361

Av ovanstående kan du finna det svårt att identifiera process-ID eftersom det visar alla PID (inklusive förälder och barn) med processnamnet.

Därför måste vi ta reda på det överordnade PID (PPID) som vi letar efter.

Det här kan bli nummer ett. I mitt fall är det 3754 och det visas i fallande ordning.

Metod-2: Använd kommandot pgrep

pgrep tittar på de aktuella processerna och listar process-ID:n som matchar urvalskriterierna för stdout.

# pgrep apache2 2361 2362 2363 2364 2365 2594 3754

Detta liknar också ovanstående utdata, men den här reducerar resultaten i stigande ordning, vilket tydligt indikerar att det överordnade PID är det sista.

I mitt fall är det 3754.

Notera. Om du har flera process-ID:n kan du ha problem med att identifiera det överordnade process-ID:n när du använder kommandot pidof & pgrep.

Metod-3: Använda kommandot pstree

pstree visar pågående processer som ett träd.

Trädet är rotat antingen vid pid eller vid init om pid utelämnas.

Om ett användarnamn anges i kommandot pstree, visas hela processen som ägs av motsvarande användare.

pstree kombinerar visuellt identiska grenar genom att placera dem inom hakparenteser och prefixa dem med antalet repetitioner.

#pstree -p | grep "apache2" |- apache2(3754)-+-apache2(2361) | |-apache2(2362) | |-apache2(2363) | |-apache2(2364) | |-apache2(2365) | `-apache2(2594)

Använd följande format för att få endast en överordnad process.

#pstree -p | grep "apache2" | huvud -1 |- apache2(3754)-+-apache2(2361)

Kommandot pstree är mycket enkelt eftersom det separerar överordnade och underordnade processer separat

Metod-4: Använda ps-kommandot

ps visar information om valet av aktiva processer.

Den visar process-ID (pid = PID), terminal som är associerad med processen (tname = TTY), kumulativ CPU-tid i formatet hh:mm:ss (tid = TIME) och exekverbart namn (ucmd = cmd).

Som standard sorteras inte utdatafilen.

# ps aux | grep "apache2" www-data 2361 0.0 0.4 302652 9732 ? S 06:25 0:00 /usr/sbin/apache2 -k start www-data 2362 0,0 0,4 302652 9732 ? S 06:25 0:00 /usr/sbin/apache2 -k start www-data 2363 0,0 0,4 302652 9732 ? S 06:25 0:00 /usr/sbin/apache2 -k start www-data 2364 0,0 0,4 302652 9732 ? S 06:25 0:00 /usr/sbin/apache2 -k start www-data 2365 0,0 0,4 302652 8400 ? S 06:25 0:00 /usr/sbin/apache2 -k start www-data 2594 0,0 0,4 302652 8400 ? S 06:55 0:00 /usr/sbin/apache2 -k start rot 3754 0,0 1,4 302580 29324 ? Ss dec11 0:23 /usr/sbin/apache2 -k start root 5648 0,0 0,0 12784 940 pts/0 S+ 21:32 0:00 grep apache2

Från ovanstående utdata kan vi enkelt identifiera det överordnade process-ID (PPID) baserat på processens startdatum.

I mitt fall startades apache2-processen av @Dec11 som är föräldern och de andra är barnen. Apache2 PID är 3754.

Metod-5: Använd ss-kommandot

ss används för att visa socketstatistik.

Det låter dig visa information som liknar netstat.

Den kan visa mer TCP- och statusinformation än andra verktyg.

Den kan visa statistik för alla typer av sockets som PACKET, TCP, UDP, DCCP, RAW, Unix-domän, etc.

# ss -tnlp | grep apache2 LISTEN 0 128:::80:::* användare:(("apache2",pid=3319,fd=4),("apache2",pid=3318,fd=4),("apache2", pid=3317,fd=4))

Metod-6: Använder kommandot netstat

netstat - Visar nätverksanslutningar, routingtabeller, gränssnittsstatistik, maskerad- och multicast-anslutningar.

Som standard visar netstat en lista över öppna uttag.

Om du inte anger några adressfamiljer kommer de aktiva uttagen för alla konfigurerade adressfamiljer att listas.

Detta program är föråldrat. Ersättaren för netstat är ss.

# netstat -tnlp | grep apache2 tcp6 0 0:::80:::* LYSSNA 3317/apache2

Metod-7: Använd lsof-kommandot

lsof - lista över öppna filer.

Kommandot lsof Linux visar information om filer som är öppna för processer som körs på systemet.

# lsof -i -P | grep apache2 apache2 3317 root 4u IPv6 40518 0t0 TCP *:80 (LYSNA) apache2 3318 www-data 4u IPv6 40518 0t0 TCP *:80 (LYSNA) apache2 3319 www-data 4u IPv6 40518 0t0 TCPS

Metod-8: Använda fixeringskommandot

Fixeringsverktyget måste skriva till standardutdata process-ID:n för processer som körs på det lokala systemet som öppnar en eller flera namngivna filer.

# fuser -v 80/tcp ANVÄNDAR PID ÅTKOMMAND 80/tcp: root 3317 F.... apache2 www-data 3318 F.... apache2 www-data 3319 F.... apache2

Metod-9: Använder systemctl-kommandot

systemctl - Hantera systemd-systemet och servicehanteraren.

Detta är en ersättning för den gamla SysV-systemhanteringen och De flesta moderna Linux-operativsystem har antagit systemd.

# systemctl status apache2 ● apache2.service - Apache HTTP-servern laddad: laddad (/lib/systemd/system/apache2.service; inaktiverad; leverantörens förinställning: aktiverad) Drop-In: /lib/systemd/system/apache2.service. d └─apache2-systemd.conf Aktiv: aktiv (kör) sedan tis 2018-09-25 10:03:28 IST; 3s sedan Process: 3294 ExecStart=/usr/sbin/apachectl start (kod=avslutad, status=0/SUCCESS) Huvud-PID: 3317 (apache2) Uppgifter: 55 (gräns: 4915) Minne: 7,9M CPU: 71ms CGroup: /system.slice/apache2.service ├─3317 /usr/sbin/apache2 -k start ├─3318 /usr/sbin/apache2 -k start └ ─3319 /usr/sbin/apache2 -k start 25 sep 10:03:28 ubuntu systemd: Startar Apache HTTP-servern... 25 sep 10:03:28 ubuntu systemd: Startade Apache HTTP-servern.

Tror du att operativsystemet Linux automatiskt kan sköta sig självt? När allt fungerar bra eller du inte behöver några icke-standardiserade funktioner, ja. Men ibland kan ditt ingripande i hennes arbete vara nödvändigt.

I Linux skapas en process för varje enskilt program när det startar. Det spelar ingen roll om du kör programmet manuellt själv eller om systemet eller kärnan gör det. Till exempel har initialiseringsprogrammet, som körs direkt efter att kärnan har laddats, också en egen process med ID 0. Processer i Linux kan beskrivas som behållare där all information om programmets tillstånd och exekvering lagras. Om programmet fungerar bra är allt bra, men om det fryser eller du behöver justera dess arbete kan du behöva processhantering i Linux.

Den här artikeln kommer att täcka ett brett ämne och vi kommer att titta på följande möjligheter:

• Se pågående processer
• Visa processinformation
• Hitta processer i Linux
• Avslutande processer
• Begränsa det tillgängliga minnet för en process

Jag kunde inte låta bli att inkludera de första punkterna i artikeln, men de är väldigt enkla och vi kommer inte att gå in på dem i detalj. Men allt annat kan tyckas komplicerat och otillräckligt beskrivet.

Låt oss börja med att förstå villkoren. I huvudsak är en process varje program. Som jag redan har sagt skapas en separat process för varje lanserat program. Som en del av en process tilldelas ett program CPU-tid, RAM-minne och andra systemresurser. Varje process har sin egen identifierare, Process ID eller helt enkelt PID, och Linux-processer identifieras oftast av dem. PID bestäms inte slumpmässigt som jag redan sa, initieringsprogrammet får PID 1, och varje efterföljande startat program får ett till. Således når PID för användarprogram flera tusen.

Faktum är att Linux-processer inte är så abstrakta som de verkar för dig nu. Du kan försöka känna dem. Öppna din filhanterare, gå till rotkatalogen och öppna sedan mappen /proc. Ser du ett gäng siffror här? Så detta är allt - PID för alla pågående processer. Var och en av dessa mappar innehåller all information om processen.

Låt oss till exempel titta på mappen för process 1. Mappen innehåller andra underkataloger och många filer. Cmdline-filen innehåller information om processstartkommandot:

cat /proc/1/cmdline

/usr/lib/systemd/systemd

Eftersom jag använder Systemd-initieringssystemet, startas den första processen för det. Du kan göra allt med katalogen /proc. Men detta är väldigt obekvämt, särskilt med tanke på antalet pågående processer i systemet. Därför finns det speciella verktyg för att genomföra de nödvändiga uppgifterna. Låt oss gå vidare och överväga verktyg som låter dig implementera processhantering i Linux.

Processhantering i Linux

Linux har ett mycket stort antal verktyg för att lösa olika processhanteringsuppgifter. Dessa inkluderar sådana multifunktionella lösningar som htop, top, såväl som enkla verktyg, till exempel, ps, kill, killall, who, etc. Jag kommer inte att överväga grafiska verktyg i den här artikeln, och jag kommer inte att överväga top heller. Det första är för att det är för enkelt, det andra beror på att htop är bättre. Vi kommer att fokusera på att arbeta med htop-programmet och dess analoger i form av GNU-liknande verktyg, ett verktyg - en funktion.

Låt oss installera htop om du inte redan har det installerat. I Ubuntu görs detta så här:

sudo apt installera htop

På andra distributioner behöver du bara använda din pakethanterare. Paketnamnet är detsamma.

Se pågående processer

Detta är en mycket enkel uppgift, och den är också lätt att lösa. Det finns många verktyg för detta, allt från den vanliga ps till den mer avancerade interaktiva toppen, htop och så vidare.

Efter att ha öppnat htop ser vi omedelbart en lista över pågående processer. Naturligtvis visas inte alla Linux-processer här, det finns många av dem i systemet, du vet redan, de passar inte alla på en skärm. Som standard visas processer som körs som din användare:

Du kan se följande information om processen:

• PID- Processidentifierare
• ANVÄNDARE- den användare från vilken processen startade
• PRI- linux processprioritet på kärnnivå (vanligtvis NI+20)
• NI- processexekveringsprioritet från -20 till 19
• S- processtillstånd
• CPU- CPU-resurser som används
• MEM- använt minne
• TID- processtid

Du kan lägga till ytterligare parametrar till displayen, men dessa är de viktigaste. Du kan lägga till parametrar med hjälp av Setup-menyn. Allt är väldigt enkelt där, läs tipsen och följ anvisningarna. Till exempel har PPID-parametern lagts till:

En mycket viktig funktion i programmet är att du kan sortera processer i Linux enligt önskad parameter. Klicka bara på namnet på parametern, den markeras i grönt och sortering kommer att utföras. Om du till exempel vill se i vilken ordning processerna lanserades, sortera efter PID:

Det finns också ett intressant alternativ att ordna processer i ett träd. Du kommer att kunna se vilken process som startade en viss process. För att visa trädet, tryck på F5-knappen:

Du kan utföra nästan samma åtgärder med ps-programmet. Bara här finns det inget sådant bekvämt interaktivt läge. Allt görs med hjälp av alternativ.

Låt oss titta på de viktigaste alternativen som vi kommer att använda:

• -e- visa information om alla processer
• -a- visa information om alla de mest efterfrågade processerna
• -t- visa endast processer från denna terminal
• -s- visa endast information om den angivna processen
• -u- visa processer för endast en specifik användare

Kort sagt, för att se alla för närvarande aktiva processer i Linux, använd en kombination av aux-alternativ:

Programmet visar alla samma parametrar, bara det finns inget interaktivt gränssnitt. Du tror att det är omöjligt att sortera processer här, men du har fel, det är möjligt. Det finns ett sorteringsalternativ för detta. Du kan sortera dem efter vilket fält som helst, till exempel:

ps aux --sort=%mem

Listan kommer att sorteras i omvänd ordning, med fler värden längst ner och färre överst. Om du behöver göra det omvänt, lägg till ett minus:

ps aux --sort=-%cpu

Linux-processprioriteter eller andra parametrar kan användas som ett sorteringsfält. Du kan också trimma utdata om du inte behöver visa all information:

Det verkar som att ps inte har förmågan att kosta bearbetningsträd. Men inte riktigt, det finns ett separat kommando för detta:

Hitta processer i Linux

En lista över processer är bra. Men ibland, när någon process är frusen och vi behöver döda Linux-processen eller vi behöver utföra några åtgärder med den, måste vi välja den här processen från listan, ta reda på dess PID och information om den.

För att hitta linux-processen i htop kan du använda F3-knappen. Tryck på F3 och skriv önskat ord. Därefter, för att gå till nästa post, tryck på F2 eller Esc för att slutföra sökningen:

Du kan också använda htop-filtret för att söka efter processer i htop. Tryck på F4, skriv in ett ord, och endast linux-processer vars namn innehåller det ordet kommer att listas.

Det finns ingen filtrering i ps-verktyget, men vi kan använda grep-verktyget, omdirigera utdata från ps till det för att hitta linux-processen:

ps aux | grep krom

Detta är ett mycket vanligt använda kommando.

Ändra processprioritet

Linux-processprioritet betyder hur mycket mer CPU-tid som kommer att ges till den processen jämfört med andra. På så sätt kan vi mycket finjustera vilket program som kommer att köras snabbare och vilket som kommer att köras långsammare. Prioritetsvärdet kan variera från 19 (minsta prioritet) till -20 - maximal prioritet för linux-processen. Dessutom kan du minska prioriteten med rättigheterna för en vanlig användare, men för att öka den behöver du superanvändarrättigheter.

htop använder Nice-parametern för att styra prioritet. Låt mig påminna dig om att Priv bara är ett tillägg, i de flesta fall är det 20 fler än Nice För att ändra prioritet för en process, placera helt enkelt markören på den och tryck på F7 för att minska siffran (öka prioritet) eller F8 till. öka antalet.

Men för att lösa denna uppgift att hantera Linux-processer är det inte nödvändigt att använda htop. Du kan göra allt med andra kommandon. Till exempel det trevliga kommandot. Med den kan du ange prioritet för processen som ska startas:

nice -n 10 apt-get uppgradering

Eller ändra prioriteten för en befintlig med dess pid:

renice -n 10 -s 1343

Avsluta processer i Linux

Om en process är fryst och inte svarar måste den avslutas. I htop, för att döda en Linux-process, placera helt enkelt markören på processen och tryck på F9:

Systemet använder vissa signaler för att styra processer det finns signaler som indikerar processen som ska avslutas. Här är några grundläggande signaler:

• SIGKILL- be processen att spara data och avsluta
• SIGTERM- avsluta processen omedelbart, utan att spara

I allmänhet finns det flera dussin signaler, men vi kommer inte att överväga dem. Låt oss skicka SIGKILL-signalen:

Du kan också använda kill-verktyget:

Du kan också döda en process med namn:

killall krom

Processbegränsning

Processhantering i Linux låter dig kontrollera nästan allt. Du har redan sett vad som kan göras, men ännu mer kan göras. Genom att använda kommandot ulimit och konfigurationsfilen /etc/security/limits.conf kan du begränsa processers åtkomst till systemresurser som minne, filer och processorn. Du kan till exempel begränsa Linux processminne, antal filer osv.

Posten i filen ser ut så här:

<домен> <тип> <элемент> <значение>

• domän- användarnamn, gruppnamn eller UID
• typ- typ av begränsningar - mjuk eller hård
• element- en resurs som kommer att vara begränsad
• menande- erforderlig gräns

Hårda gränser sätts av superanvändaren och kan inte ändras av vanliga användare. Mjuka gränser kan ändras av användare med kommandot ulimit.

Låt oss titta på de huvudsakliga begränsningarna som kan tillämpas på processer:

• ingen fil
• som- maximal mängd RAM
• stack- maximal stackstorlek
• CPU- maximal processortid
• nproc- maximalt antal processorkärnor
• lås- antal låsta filer
• trevlig- maximal processprioritet

Låt oss till exempel begränsa processortiden för användarens sergiys processer:

sergiy hard nproc 20

Du kan se begränsningarna för en specifik process i proc-mappen:

cat /proc/PID/limits

Max CPU-tid obegränsad obegränsad sekunder
Max filstorlek obegränsad obegränsad byte
Max datastorlek obegränsad obegränsad byte
Max stackstorlek 204800 obegränsade byte
Max kärnfilstorlek 0 obegränsade byte
Max resident ange obegränsat obegränsat antal byte
Max bearbetar 23562 23562 processer
Max öppna filer 1024 4096 filer
Max låst minne 18446744073708503040 18446744073708503040 byte
Max adressutrymme obegränsat obegränsat antal byte
Max fillås obegränsat obegränsat antal lås
Max väntande signaler 23562 23562 signaler
Max msgköstorlek 819200 819200 byte
Max trevlig prioritet 0 0
Max realtidsprioritet 0 0
Max realtid timeout obegränsad obegränsad oss

Begränsningar som ändras på detta sätt kommer att träda i kraft efter en omstart. Men vi kan också sätta gränser för det aktuella skalet och de processer som det skapar med hjälp av kommandot ulimit.

Här är kommandoalternativen:

• -S- mjuk gräns
• -H- hård gräns
• -a- visa all information
• -f- maximal storlek på skapade filer
• -n- maximalt antal öppna filer
• -s- maximal stackstorlek
• -t- maximal processortid
• -u- maximalt antal pågående processer
• -v- maximal mängd virtuellt minne

Till exempel kan vi sätta en ny gräns för antalet filer som kan öppnas:

Låt oss nu titta:

Låt oss ställa in RAM-gränsen:

ulimit -Sv 500 000

Låt mig påminna dig om att denna begränsning kommer att gälla för alla program som körs i denna terminal.

Slutsatser

Det är allt. Nu kommer det inte att orsaka problem att hantera processer i Linux. Vi undersökte detta ämne mycket detaljerat. Om du har några frågor eller förslag för att lägga till artikeln, skriv i kommentarerna!