Prozesse unter Linux verstehen

Dieses Tutorial enthält Details darüber, was Prozesse sind, wie sie verwendet werden und wie sie unter Linux verwaltet werden können.

Als Systemadministrator haben Sie wahrscheinlich mit Prozessen interagiert auf viele verschiedene Arten.

Manchmal möchten Sie möglicherweise Befehle ausführen, um Prozesse zu identifizieren, die viele Ressourcen verbrauchen auf Ihrem Host.

Möglicherweise haben Sie einen Anruf von einem Benutzer erhalten, der besagt, dass einer seiner Prozesse hängen geblieben ist und dass Sie ihn möglicherweise beenden müssen, um weiterarbeiten zu können.

Prozesse stehen wirklich im Mittelpunkt des Linux-Betriebssystems:Vom Kernel selbst erstellt, sie stellen laufende Operationen dar, die derzeit auf Ihrem Linux-Host stattfinden.

Prozesse sind überall, sie können im Hintergrund laufen oder Sie können sie selbst für benutzerdefinierte Operationen initialisieren.

Sie können wählen, ob Sie starten möchten sie zu unterbrechen sie, um fortzufahren sie oder aufzuhören sie.

Im heutigen Tutorial werfen wir einen sehr genauen Blick auf Prozesse, was sie sind und wie sie auf unserem Betriebssystem verwendet werden.

Wir werden alle mit Prozessen verbundenen Befehle entdecken, was Signale sind und wie wir unseren bestehenden Prozessen mehr Rechenressourcen zuweisen können.

Bereit?

Was Sie lernen werden

Wenn Sie dieses Tutorial bis zum Ende lesen, lernen Sie die folgenden Konzepte kennen

• Welche Prozesse sind und wie sie erstellt werden auf einem Linux-System
• Wie Prozesse identifiziert werden können auf einem Linux-System
• Welcher Hintergrund und Vordergrund Prozesse sind
• Welche Signale sind und wie sie verwendet werden können, um mit Prozessen zu interagieren
• Verwendung des pgrep sowie das pkill Befehl effektiv
• Anpassen der Prozesspriorität mit nice und renice
• So sehen Sie Prozessaktivitäten in Echtzeit unter Linux

Das ist ein ziemlich langes Programm, also beginnen wir ohne weiteres mit einer kurzen Beschreibung dessen, was Prozesse sind.

Grundlagen von Linux-Prozessen

Kurz gesagt, Prozesse führen Programme auf Ihrem Linux-Host aus die Vorgänge ausführen, wie z. B. das Schreiben auf eine Festplatte, das Schreiben in eine Datei oder das Ausführen eines Webservers.

Prozesse haben einen Inhaber und sie werden durch eine Prozess-ID identifiziert (auch PID genannt )

Andererseits Programme sind Zeilen oder Code oder Zeilen von Maschinenanweisungen, die auf einem dauerhaften Datenspeicher gespeichert sind.

Sie können einfach auf Ihrem Datenspeicher sitzen oder in Ausführung sein, d. h. als Prozesse ausgeführt werden.

Um die ihnen zugewiesenen Vorgänge auszuführen, benötigen Prozesse Ressourcen :CPU-Zeit , Speicher (z. B. RAM oder Speicherplatz ), aber auch virtueller Speicher wie Auslagerungsspeicher falls Ihr Prozess zu gierig wird.

Offensichtlich können Prozesse gestartet werden , angehalten , unterbrochen und sogar getötet .

Bevor Sie irgendwelche Befehle ausgeben, sehen wir uns an, wie Prozesse vom Kernel selbst erstellt und verwaltet werden.

Prozessinitialisierung unter Linux

Wie bereits erwähnt, werden Prozesse vom Kernel verwaltet auf Linux.

Es gibt jedoch ein Kernkonzept, das Sie verstehen müssen, um zu wissen, wie Linux Prozesse erstellt.

Wenn Sie ein Linux-System booten, wird Ihr Linux-Kernel standardmäßig in den Arbeitsspeicher geladen, ihm wird ein virtuelles Dateisystem im Arbeitsspeicher zugewiesen (auch initramfs genannt ) und die Initialisierungsbefehle werden ausgeführt.

Einer dieser Befehle startet den allerersten Prozess unter Linux.

Früher wurde dieser Prozess Init-Prozess genannt, aber er wurde bei vielen neueren Linux-Distributionen durch den systemd-Initialisierungsprozess ersetzt.

Führen Sie zum Beweis den folgenden Befehl auf Ihrem Host aus

$ ps -aux | head -n 2

Wie Sie sehen können, hat der systemd-Prozess eine PID von 1.

Wenn Sie alle Prozesse auf Ihrem System mit einer Baumanzeige drucken würden, würden Sie feststellen, dass alle Prozesse untergeordnete Prozesse von systemd sind.

$ pstree

Es ist bemerkenswert, die Tatsache zu betonen, dass all diese Initialisierungsschritte (mit Ausnahme des Starts des anfänglichen Prozesses) in einem reservierten Bereich namens Kernel-Bereich durchgeführt werden.

Der Kernel-Speicherplatz ist ein für den Kernel reservierter Speicherplatz damit wichtige Systemtools ordnungsgemäß ausgeführt werden und sichergestellt ist, dass Ihr gesamter Host konsistent ausgeführt wird.

Andererseits ist Benutzerplatz für Prozesse reserviert vom Benutzer gestartet und vom Kernel selbst verwaltet.

Folglich ist der systemd-Prozess der allererste Prozess, der im Benutzerbereich gestartet wird.

Prozesserstellung mit Fork und Exec

Wenn Sie ein Programm unter Linux erstellen und ausführen, umfasst dies im Allgemeinen zwei Hauptschritte:fork und ausführen .

Gabelbetrieb

Fork ist eine Klonoperation, sie nimmt den aktuellen Prozess, auch Elternprozess genannt, und klont ihn in einen neuen Prozess mit einer brandneuen Prozess-ID.

Beim Forken wird alles aus dem übergeordneten Prozess kopiert:der Stack , der Haufen , sondern auch die Dateideskriptoren, die die Standardeingabe, die Standardausgabe und den Standardfehler. bedeuten

Das bedeutet, dass, wenn mein übergeordneter Prozess in die aktuelle Shell-Konsole geschrieben hat, der untergeordnete Prozess auch in die Shell-Konsole schreibt.

Die Ausführung des geklonten Prozesses beginnt auch mit derselben Anweisung wie der übergeordnete Prozess.

Vorgang ausführen

Die Ausführungsoperation wird unter Linux verwendet, um das aktuelle Prozessabbild durch das Abbild eines anderen Prozesses zu ersetzen.

Im vorherigen Diagramm haben wir gesehen, dass der Stack des übergeordneten Prozesses drei verbleibende Anweisungen enthielt.

Folglich wurden die Anweisungen in den neuen Prozess kopiert, aber sie sind für das, was wir ausführen möchten, nicht relevant.

Die exec-Operation ersetzt das Prozessabbild (d. h. den Satz von Anweisungen, die ausgeführt werden müssen) durch ein anderes.

Wenn Sie beispielsweise den exec-Befehl in Ihrem Bash-Terminal ausführen würden, würde Ihre Shell beendet werden, sobald der Befehl abgeschlossen ist, da Ihr aktuelles Prozessabbild (Ihr Bash-Interpreter) durch den Kontext des Befehls ersetzt würde, den Sie zu starten versuchen .

$ exec ls -l

Wenn Sie die beim Erstellen eines Prozesses ausgeführten Systemaufrufe nachverfolgen würden, würden Sie feststellen, dass der erste aufgerufene C-Befehl der exec-Befehl ist.

Erstellen von Prozessen aus einer Shell-Umgebung

Wenn Sie eine Shell-Konsole starten, gelten genau die gleichen Prinzipien, wenn Sie einen Befehl starten.

Eine Shell-Konsole ist ein Prozess, der auf Eingaben des Benutzers wartet.

Es startet auch einen Bash-Interpreter, wenn Sie die Eingabetaste drücken, und bietet eine Umgebung für die Ausführung Ihrer Befehle.

Aber die Shell folgt den Schritten, die wir zuvor beschrieben haben.

Wenn Sie die Eingabetaste drücken, wird die Shell zu einem untergeordneten Prozess verzweigt das wird für die Ausführung Ihres Befehls verantwortlich sein. Die Shell wird geduldig warten, bis die Ausführung des untergeordneten Prozesses beendet ist.

Andererseits ist der untergeordnete Prozess mit denselben Dateideskriptoren verknüpft und es kann Variablen gemeinsam nutzen, die auf globaler Ebene deklariert wurden.

Der untergeordnete Prozess führt die Datei „exec ”-Befehl, um das aktuelle Prozessabbild (das das Shell-Prozessabbild ist) im Prozessabbild des auszuführenden Befehls zu ersetzen.

Der untergeordnete Prozess wird schließlich beendet und gibt sein Ergebnis an die Standardausgabe aus, die er vom übergeordneten Prozess geerbt hat, in diesem Fall die Shell-Konsole selbst.

Nachdem Sie nun einige Grundlagen darüber haben, wie Prozesse in Ihrer Linux-Umgebung erstellt werden, sehen wir uns einige Details zu Prozessen an und wie sie leicht identifiziert werden können.

Laufende Prozesse unter Linux identifizieren

Der einfachste Weg, laufende Prozesse unter Linux zu identifizieren, ist die Ausführung von ps Befehl.

$ ps

Standardmäßig zeigt Ihnen der Befehl ps die Liste der aktuell laufenden Prozesse, die dem aktuellen Benutzer gehören.

In diesem Fall laufen für meinen Benutzer nur zwei Prozesse:der Bash-Interpreter und den ps-Befehl Ich bin darauf gestoßen.

Der wichtige Teil hier ist, dass Prozesse Besitzer haben , meistens der Benutzer, der sie überhaupt ausgeführt hat.

Lassen Sie uns zur Veranschaulichung die ersten zehn Prozesse Ihres Linux-Betriebssystems mit einem anderen Anzeigeformat auflisten.

$ ps -ef | head -n 10

Wie Sie hier sehen können, gehören die Top-Ten-Prozesse dem Benutzer „root “.

Diese Informationen sind besonders wichtig, wenn es um die Interaktion mit Prozessen mit Signalen geht.

Um die Prozesse anzuzeigen, die dem aktuell verbundenen Benutzer gehören und von ihm ausgeführt werden, führen Sie den folgenden Befehl aus

$ ps u

Es gibt viele verschiedene Optionen für den ps-Befehl, und sie können durch Ausführen des manuellen Befehls angezeigt werden.

$ man ps

Erfahrungsgemäß sind die beiden wichtigsten Befehle, um laufende Prozesse zu sehen,

ps aux

USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND

Das entspricht einem Prozess-Listing im BSD-Stil , wobei der folgende Befehl

ps -ef

UID  PID  PPID C STIME TTY  TIME CMD

Entspricht einer Prozessauflistung im POSIX-Stil .

Sie repräsentieren beide aktuell laufende Prozesse auf einem System, aber der erste hat die Option „u“ für „benutzerorientiert“, was das Lesen von Prozessmetriken erleichtert.

Nachdem Sie nun gesehen haben, was Prozesse sind und wie sie aufgelistet werden können, sehen wir uns an, welche Hintergrund- und Vordergrundprozesse sich auf Ihrem Host befinden.

Hintergrund- und Vordergrundprozesse

Die Definition von Hintergrund- und Vordergrundprozessen ist ziemlich selbsterklärend.

Jobs und Prozesse in der aktuellen Shell

Ein Hintergrundprozess unter Linux ist ein Prozess, der im Hintergrund ausgeführt wird, was bedeutet, dass er nicht aktiv von einem Benutzer beispielsweise über eine Shell verwaltet wird.

Auf der anderen Seite ist ein Vordergrundprozess ein Prozess, mit dem über direkte Benutzereingaben interagiert werden kann.

Nehmen wir zum Beispiel an, Sie haben ein Shell-Terminal geöffnet und den folgenden Befehl in Ihre Konsole eingegeben.

$ sleep 10000

Wie Sie wahrscheinlich bemerkt haben, bleibt Ihr Terminal bis zur Beendigung des Schlafvorgangs hängen. Folglich wird der Prozess nicht im Hintergrund, sondern im Vordergrund ausgeführt.

Ich kann damit interagieren. Wenn ich Strg + Z drücke, wird zum Beispiel direkt ein Stoppsignal an den Prozess gesendet.

Es gibt jedoch eine Möglichkeit, den Prozess im Hintergrund auszuführen.

Um einen Prozess im Hintergrund auszuführen, setzen Sie einfach ein „& ” Zeichen am Ende Ihres Befehls.

$ sleep 10000 &

Wie Sie sehen können, wurde die Kontrolle direkt an den Benutzer zurückgegeben und der Prozess wurde im Hintergrund ausgeführt

Um Ihren laufenden Prozess im Kontext der aktuellen Shell zu sehen, können Sie den Befehl jobs

ausführen

$ jobs

Jobs sind eine Liste von Prozessen, die im Kontext der aktuellen Shell gestartet wurden und möglicherweise noch im Hintergrund laufen.

Wie Sie im obigen Beispiel sehen können, laufen derzeit zwei Prozesse im Hintergrund.

Die verschiedenen Spalten von links nach rechts repräsentieren dieJob-ID, den Prozessstatus (die Sie im nächsten Abschnitt entdecken werden) und der ausgeführte Befehl.

Verwendung der bg- und fg-Befehle

Um mit Jobs zu interagieren, stehen Ihnen zwei Befehle zur Verfügung:bg und fg .

Der bg-Befehl wird unter Linux verwendet, um einen Prozess in den Hintergrund zu schicken und die Syntax ist wie folgt

$ bg %<job_id>

Um einen Prozess in den Vordergrund zu schicken, können Sie auf ähnliche Weise das fg verwenden in gleicher Weise

$ fg %<job_id>

Wenn wir zur Liste der Jobs unseres vorherigen Beispiels zurückkehren und den Job 3 in den Vordergrund bringen möchten, dh in das aktuelle Shell-Fenster, würde ich den folgenden Befehl ausführen

$ fg %3

Durch Ausgabe eines Strg + Z-Befehls kann ich den Prozess stoppen. Ich kann es mit einem bg-Befehl verknüpfen, um es in den Hintergrund zu schicken.

Nachdem Sie nun eine bessere Vorstellung davon haben, was Hintergrund- und Vordergrundprozesse sind, sehen wir uns an, wie Sie mithilfe von Signalen mit Prozessen interagieren können.

Interaktion mit Prozessen mithilfe von Signalen

Unter Linux sind Signale eine Form der Kommunikation zwischen Prozessen (auch IPC genannt ), das asynchrone Benachrichtigungen über das Eintreten eines bestimmten Ereignisses erstellt und an laufende Prozesse sendet.

Signale werden oft verwendet, um einen Kill zu senden oder ein Beendigungsbefehl an einen Prozess, um ihn zu beenden (auch Kill-Signal genannt).

Um ein Signal an einen Prozess zu senden, müssen Sie den kill verwenden Befehl.

$ kill -<signal number> <pid>|<process_name>

Um beispielsweise einen HTTPD-Prozess (PID =123) zum Beenden (ohne sauberes Herunterfahren) zu zwingen, würden Sie den folgenden Befehl ausführen

$ kill -9 123

Signalkategorien erklärt

Wie bereits erläutert, gibt es viele Signale, die man senden kann, um einen bestimmten Prozess zu benachrichtigen.

Hier ist die Liste der am häufigsten verwendeten:

• SIGNAL :Abkürzung für Signal Interrupt ist ein Signal, das verwendet wird, um einen laufenden Prozess zu unterbrechen. Es ist auch das Signal, das gesendet wird, wenn ein Benutzer Strg + C auf einem Terminal gedrückt hat;
• SIGHUP :Kurz für signal hangup ist das Signal, das Ihr Terminal sendet, wenn es geschlossen wird. Ähnlich wie bei einem SIGINT endet der Prozess;
• SIGKILL :Signal, das verwendet wird, um einen Prozess zum Stoppen zu zwingen, unabhängig davon, ob er ordnungsgemäß gestoppt werden kann oder nicht. Dieses Signal kann nicht ignoriert werden, außer für den Init-Prozess (oder den Systemd-Prozess bei neueren Distributionen);

• SIGQUIT :Spezifisches Signal, das gesendet wird, wenn ein Benutzer den aktuellen Prozess beenden oder verlassen möchte. Es kann durch Drücken von Strg + D aufgerufen werden und wird häufig in Terminal-Shells oder in SSH-Sitzungen verwendet;
• SIGUSR1, SIGUSR2 :Diese Signale werden ausschließlich zu Kommunikationszwecken verwendet und können in Programmen verwendet werden, um benutzerdefinierte Handler zu implementieren;
• SIGSTOP :Weist den Prozess an, seine Ausführung zu stoppen, ohne den Prozess zu beenden. Der Prozess wartet dann darauf, fortgesetzt oder vollständig beendet zu werden;
• SIGKONT :Wenn der Prozess als gestoppt markiert ist, weist es den Prozess an, seine Ausführung erneut zu starten.

Um die vollständige Liste aller verfügbaren Signale anzuzeigen, können Sie den folgenden Befehl ausführen

$ kill -l

 1) SIGHUP       2) SIGINT       3) SIGQUIT      4) SIGILL
 5) SIGTRAP      6) SIGABRT      7) SIGBUS       8) SIGFPE
 9) SIGKILL     10) SIGUSR1     11) SIGSEGV     12) SIGUSR2
13) SIGPIPE     14) SIGALRM     15) SIGTERM     16) SIGSTKFLT
17) SIGCHLD     18) SIGCONT     19) SIGSTOP     20) SIGTSTP
21) SIGTTIN     22) SIGTTOU     23) SIGURG      24) SIGXCPU
25) SIGXFSZ     26) SIGVTALRM   27) SIGPROF     28) SIGWINCH
29) SIGIO       30) SIGPWR      31) SIGSYS      34) SIGRTMIN
35) SIGRTMIN+1  36) SIGRTMIN+2  37) SIGRTMIN+3  38) SIGRTMIN+4
39) SIGRTMIN+5  40) SIGRTMIN+6  41) SIGRTMIN+7  42) SIGRTMIN+8
43) SIGRTMIN+9  44) SIGRTMIN+10 45) SIGRTMIN+11 46) SIGRTMIN+12
47) SIGRTMIN+13 48) SIGRTMIN+14 49) SIGRTMIN+15 50) SIGRTMAX-14
51) SIGRTMAX-13 52) SIGRTMAX-12 53) SIGRTMAX-11 54) SIGRTMAX-10
55) SIGRTMAX-9  56) SIGRTMAX-8  57) SIGRTMAX-7  58) SIGRTMAX-6
59) SIGRTMAX-5  60) SIGRTMAX-4  61) SIGRTMAX-3  62) SIGRTMAX-2
63) SIGRTMAX-1  64) SIGRTMAX

Signal- und Prozesszustände

Nachdem Sie nun wissen, dass es möglich ist, Prozesse zu unterbrechen, zu beenden oder zu stoppen, ist es an der Zeit, sich mit Prozesszuständen vertraut zu machen.

Prozesse haben viele verschiedene Zustände, sie können sein:

• Läuft :Laufende Prozesse sind diejenigen, die in der aktuellen Zeit etwas Rechenleistung (z. B. CPU-Zeit) verbrauchen. Ein Prozess kann auch als „lauffähig“ bezeichnet werden, wenn alle Laufbedingungen erfüllt sind und er auf etwas CPU-Zeit durch den CPU-Scheduler wartet.
• Gestoppt :Ein Signal wird gestoppt ist mit dem Signal SIGSTOP oder mit der Tastenkombination Strg + Z verknüpft. Die Prozessausführung wird ausgesetzt und wartet entweder auf ein SIGCONT oder auf ein SIGKILL.
• Schlafen :Ein schlafender Prozess ist ein Prozess, der auf ein Ereignis oder die Verfügbarkeit einer Ressource (wie einer Festplatte) wartet.

Hier ist ein Diagramm, das die verschiedenen Prozesszustände darstellt, die mit den Signalen verknüpft sind, die Sie an sie senden können.

Nachdem Sie nun etwas mehr über Prozesszustände wissen, werfen wir einen Blick auf die Befehle pgrep und pkill.

Prozess manipulieren mit pgrep und pkill

Unter Linux können Sie bereits eine Menge tun, indem Sie einfach den Befehl ps verwenden.

Sie können Ihre Suche auf einen bestimmten Prozess eingrenzen und die PID verwenden, um ihn vollständig zu beenden.

Es gibt jedoch zwei Befehle, die entwickelt wurden, um Ihre Befehle noch kürzer zu machen:pgrep und pkill

Mit dem pgrep-Befehl

Das pgrep Der Befehl ist eine Abkürzung für die Verwendung des Befehls ps, der mit dem Befehl grep geleitet wird.

Der Befehl pgrep sucht anhand eines Namens oder eines definierten Musters nach allen Vorkommen eines bestimmten Prozesses.

Die Syntax des pgrep-Befehls ist die folgende

$ pgrep <options> <pattern>

Wenn Sie beispielsweise nach allen Prozessen mit dem Namen „bash“ auf Ihrem Host suchen würden, würden Sie den folgenden Befehl ausführen

$ pgrep bash

Der Befehl pgrep ist standardmäßig nicht auf die Prozesse beschränkt, die dem aktuellen Benutzer gehören.

Wenn ein anderer Benutzer den bash-Befehl ausführen würde, würde er in der Ausgabe des pgrep-Befehls erscheinen.

Es ist auch möglich, mit Globbing-Zeichen nach Prozessen zu suchen.

Mit dem pkill-Befehl

Andererseits ist der pkill-Befehl auch eine Abkürzung für den ps-Befehl, der mit dem kill-Befehl verwendet wird.

Der pkill-Befehl wird verwendet, um Signale an Prozesse basierend auf ihren IDs oder ihren Namen zu senden.

Die Syntax des pkill-Befehls lautet wie folgt

$ pkill <options> <pattern>

Wenn Sie beispielsweise alle Firefox-Fenster auf Ihrem Host beenden möchten, führen Sie den folgenden Befehl aus

$ pkill firefox

Ähnlich wie beim pgrep-Befehl haben Sie die Möglichkeit, Ihre Ergebnisse einzugrenzen, indem Sie einen Benutzer mit der Option -u angeben.

Um alle Prozesse zu beenden, die mit „fire“ beginnen und dem aktuellen Benutzer und root gehören, würden Sie den folgenden Befehl ausführen

$ pkill user,root fire*

Wenn Sie nicht über die Berechtigung verfügen, einen Prozess zu stoppen, erhalten Sie eine Fehlermeldung zur Berechtigung verweigert in Ihrer Standardausgabe.

Sie haben auch die Möglichkeit, bestimmte Signale zu senden, indem Sie die Signalnummer im Befehl pkill

angeben

Um beispielsweise Firefox mit einem SIGSTOP-Signal zu stoppen, würden Sie den folgenden Befehl ausführen

$ pkill -19 firefox

Anpassen der Prozesspriorität mit nice und renice

Unter Linux haben nicht alle Prozesse die gleiche Priorität, wenn es um die CPU-Zeit geht.

Einigen Prozessen, wie z. B. sehr wichtigen Prozessen, die von root ausgeführt werden, wird eine höhere Priorität gegeben, damit das Betriebssystem an Aufgaben arbeiten kann, die für das System wirklich wichtig sind.

Die Prozesspriorität unter Linux wird Nice-Level genannt.

Das nette Niveau ist eine Prioritätsskala, die von -20 bis 19 reicht.

Je niedriger Sie auf der Nettigkeitsskala gehen, desto höher wird die Priorität sein.

Je höher Sie auf der Nettigkeitsskala stehen, desto niedriger ist Ihre Priorität.

Um sich daran zu erinnern, können Sie sich an die Tatsache erinnern, dass “je netter Sie sind, desto mehr Sie bereit sind, Ressourcen mit anderen zu teilen”.

Um ein bestimmtes Programm oder einen bestimmten Prozess mit einem bestimmten netten Level zu starten, führen Sie den folgenden Befehl aus

$ nice -n <level> <command>

Um beispielsweise den tar-Befehl mit einer benutzerdefinierten tar-Ebene auszuführen, würden Sie den folgenden Befehl ausführen

$ nice -n 19 tar -cvf test.tar file

Ebenso können Sie den renice-Befehl verwenden, um den Nice-Level eines laufenden Prozesses auf einen bestimmten Wert zu setzen.

$ renice -n <priority> <pid>

Wenn ich zum Beispiel einen laufenden Prozess mit der PID 123 habe, kann ich den Befehl renice verwenden, um seine Priorität auf einen bestimmten Wert zu setzen.

$ renice -n 18 123

Nettheit und Berechtigungen

Wenn Sie kein Mitglied der sudo-Gruppe sind (oder ein Mitglied der wheel-Gruppe bei Red Hat-basierten Distributionen), gibt es einige Einschränkungen hinsichtlich dessen, was Sie mit dem nice-Befehl tun können.

Versuchen Sie zur Veranschaulichung, den folgenden Befehl als Nicht-Sudo-Benutzer

auszuführen

$ nice -n -1 tar -cvf test.tar file

nice: cannot set niceness: Permission denied

Wenn es um Nettigkeit geht, gibt es eine Regel, die Sie kennen müssen:

Als Nicht-Root- (oder sudo-) Benutzer können Sie kein nettes Level niedriger als das standardmäßig zugewiesene (das null ist) festlegen, und Sie können einen laufenden Prozess nicht neu kündigen ein niedrigeres Niveau als das aktuelle.

Um den letzten Punkt zu veranschaulichen, starten Sie im Hintergrund einen Schlafbefehl mit einem netten Wert von 2.

$ nice -n 2 sleep 10000 &

Identifizieren Sie als Nächstes die Prozess-ID des gerade erstellten Prozesses.

Versuchen Sie nun, das Nice-Level Ihres Prozesses auf einen Wert zu setzen, der niedriger ist als der Wert, den Sie ursprünglich angegeben haben.

$ renice -n 1 8363

Wie Sie wahrscheinlich bemerkt haben, können Sie die Nettigkeitsstufe nicht auf 1 setzen, sondern nur auf einen höheren Wert als den von Ihnen angegebenen.

Wenn Sie sich jetzt dafür entscheiden, den Befehl als sudo auszuführen, können Sie den Nice-Level auf einen niedrigeren Wert setzen.

Nachdem Sie nun eine klare Vorstellung von den nice- und renice-Befehlen haben, sehen wir uns an, wie Sie Ihre Prozesse unter Linux in Echtzeit überwachen können.

Überwachung von Prozessen unter Linux mit top und htop

In einem früheren Artikel haben wir besprochen, wie es möglich ist, eine vollständige Überwachungspipeline aufzubauen, um Linux-Prozesse in Echtzeit zu überwachen.

Top unter Linux verwenden

Top ist ein interaktiver Befehl, den jeder Benutzer ausführen kann, um eine vollständige und geordnete Liste aller Prozesse zu erhalten, die auf einem Linux-Host ausgeführt werden.

Um top auszuführen, führen Sie es einfach ohne Argumente aus.

Top läuft im interaktiven Modus.

$ top

Wenn Sie top für eine benutzerdefinierte Anzahl von Iterationen ausführen möchten, führen Sie den folgenden Befehl aus

$ top -n <number>

Der top-Befehl zeigt zunächst zusammenfassende Statistiken über Ihr System ganz oben an, zum Beispiel die Anzahl der laufenden Tasks, den Prozentsatz der verwendeten CPU oder den Speicherverbrauch.

Direkt darunter haben Sie Zugriff auf eine Live-Liste aller Prozesse, die auf Ihrem Host laufen oder schlafen.

Diese Ansicht wird alle drei Sekunden aktualisiert, aber Sie können diesen Parameter natürlich anpassen.

Um die Aktualisierungsrate im obersten Befehl zu erhöhen, drücken Sie den Befehl „d“ und wählen Sie eine neue Aktualisierungsrate aus

Ebenso können Sie den netten Wert eines laufenden Prozesses live ändern, indem Sie die Taste „r“ auf Ihrer Tastatur drücken.

Dieselben Berechtigungsregeln gelten, wenn Sie Prozesse auf einen niedrigeren Wert als den bereits zugewiesenen ändern möchten.

Infolgedessen müssen Sie den Befehl möglicherweise als sudo.

ausführen

Htop unter Linux verwenden

Wenn Sie nach einer schöneren Möglichkeit suchen, Prozesse auf Ihrem Linux-Host zu visualisieren, können Sie alternativ den Befehl htop verwenden.

Standardmäßig ist der htop-Befehl auf den meisten Distributionen nicht verfügbar, daher müssen Sie ihn mit den folgenden Anweisungen installieren.

$ sudo apt-get update
$ sudo apt-get install htop

Wenn Sie eine auf Red Hat basierende Distribution ausführen, führen Sie die folgenden Befehle aus.

$ sudo yum -y install epel-release
$ sudo yum -y update
$ sudo yum -y install htop

Um schließlich den htop-Befehl auszuführen, führen Sie ihn einfach ohne Argumente aus.

$ htop

Wie Sie sehen können, ist die Ausgabe sehr ähnlich, außer dass sie Informationen in einer benutzerfreundlicheren Ausgabe darstellt.

Schlussfolgerung

In diesem Tutorial haben Sie viele Konzepte über Prozesse gelernt:wie sie erstellt werden, wie sie verwaltet und wie sie effektiv überwacht werden können.

Wenn Sie nach weiteren Tutorials zur Linux-Systemadministration suchen, haben wir einen vollständigen Abschnitt auf der Website, der diesem Thema gewidmet ist, also schauen Sie es sich unbedingt an.