Prozessverwaltung


Wenn der Kernel beim Systemstart alle Module initialisiert hat, übergibt er die Kontrolle an init. Init ist somit immer der erste Prozess, der nach dem Laden des Kernels gestartet wird. Jedem Prozess wird eine Eindeutige PID = Prozessid zugewiesen. Init (PID 1) ist immer der erste und letzte Prozess im System. Ausführbare Programme werden unter Linux mit dem x-bit versehen. (siehe Dateizugriffsrechte und Dateieigentum).
Ein Programm läßt sich, sofern der Verzeichnispfad des Programms in der Umgebungsvariablen „$PATH“ gelistet ist mit dem Programmnamen von jedem Verzeichnis aus in der Konsole starten. Befindet man sich im gleichen Verzeichnis startet man das Programm mit „./<programm>“, ansonsten muß man den gesamten Pfad zur Datei angeben.


Beispiel mit pstree:

init─┬─acpid
     ├─apache2───10*[apache2]
     ├─atd
     ├─cron
     ├─dbus-daemon
     ├─dhclient3
     ├─exim4
      ......



Beispiel Umgebungsvariable $PATH:

user@home:~# echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin






procinfo


Prozessinformationen mit „procinfo“ anzeigen lassen.


Syntax:

  • procinfo [Optionen]



Optionen:

  • -fn2 ⇒ aktualisierungsinterval 2sec



Beispiel:

root@debian:~# procinfo
Linux 2.6.26-2-686 (Debian 2) (gcc [can't parse]) #???  1CPU [merkur]

Memory:      Total        Used        Free      Shared     Buffers      
Mem:        516344      224640      291704           0       12344
Swap:       859436           0      859436

Bootup: Sun Oct 17 18:10:35 2010    Load average: 0.41 0.14 0.04 2/88 6478

user  :       0:01:50.74   1.7%  page in :    97610  disk 1:     6215r   10369w
nice  :       0:03:28.13   3.1%  page out:   148348
system:       0:00:34.70   0.5%  page act:    11612
IOwait:       0:01:21.21   1.2%  page dea:        0
hw irq:       0:00:00.24   0.0%  page flt:  2546653
sw irq:       0:00:00.28   0.0%  swap in :        0
idle  :       1:43:09.17  93.4%  swap out:        0
uptime:       1:50:24.09         context :   230816

irq    0:    344549 timer                 irq    7:         0 parport0             
irq    1:         1 i8042                 irq    8:         0 rtc0                 
irq    2:         0 cascade [4]           irq    9:         0 acpi,                
irq    3:         2                       irq   10:      3900 eth0                 
irq    4:         2                       irq   11:         0 ohci_hcd:usb2        
irq    5:         0 parport1              irq   14:         0 ide0                 
irq    6:         5 floppy [2]            irq   15:         0 ide1              






Um Prozesse zur Laufzeit zu beeinflussen kann man Signale an die Prozesse senden. Es können belibig viele Jobs im Hintergrund laufen, im Vordergrund nur einer.


Folgendes Kommando zeigt eine Listung aller Signale:

user@home:~# 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	


  • SIGHUP ⇒ Hang up Signal wird Benutzt um Prozesse, die als Deamon laufen, ihre Konfigurationsdatei neu einzulesen.
  • SIGKILL ⇒ Beendet einen Prozess mit Gewalt. Nur im Notfall verwenden, wenn Signal 15 nichts bringt.
  • SIGTERM ⇒ Fordert einen Prozess auf, sich zu beenden. Der Prozess kann Aufräumarbeiten durchführen.
  • SIGINT ⇒ Führt einen Programmabbruch aus (Strg + C).
  • SIGCONT ⇒ Führt einen Prozess fort der mit SIGSTOP angehalten wurde.
  • SIGSTOP ⇒ Hält einen Prozess an.
  • SIGTSTP ⇒ Hält Prozess an, bleibt aber Speicherresistent.





Programm im Vordergrund starten


<programmname>





Programm im Hintergrund starten


<programmname> &





Laufenden Vordergrundprozess anhalten


<strg> + Z
oder
kill -SIGSTP <programmname>





bg


Angehaltenen Prozess als Backgroundprozess fortsetzen.

bg <programm>


user@home:~# bg 1
-bash: bg: job has terminated
[1]+  Done                    updatedb





fg


Background Prozess in den Vordergrund holen.

fg <jobnummer>





jobs


Liste aller Vorder. und Hintergrundprozesse.

user@home:~# jobs
[1]+  Running                 updatedb &



Optionen:

  • -l ⇒ auch PIDs der Prozesse werden angezeigt.
  • -p ⇒ nur PIDs der Prozesse werden angezeigt.





nohup


Job unabhängig von einer Shell verwenden. „nohup“ macht einen Prozess immun gegen Signale und leitet „stdout“ in eine Datei im Heimatverzeichnis um (nohup.out).


Beispiel:

nohup updatedb &
logout

Der Prozess läuft weiter.


nohup <prozessname>

Entkoppelt Eltern von Kindprozess.

Beendet man einen Elternprozess sirbt auch der Kindprozess.





ps


Zeigt eine Momentaufnahme der aktuell laufenden Prozesse an.


Syntax:

  • ps [Optionen]



Optionen Prozessauswahl:

  • a ⇒ zeigt alle Prozesse aller user die an ein Terminal geknüpft sind an.
  • -d ⇒ zeigt Prozesse, die nicht mit einem Terminal verbunden sind.
  • -A ⇒ wählt alle Prozesse aus.
  • -e ⇒ wählt alle Prozesse aus.
  • T ⇒ gibt alle Prozesse für dieses Terminal aus.
  • -N ⇒ Auswahl Negieren.
  • u ⇒ zeigt Startzeit, Pfad zur ausführbaren Datei und Benutzer an.
  • x ⇒ zeigt Prozesse mit Pfad, die nicht mit einem Terminal verbunden sind.
  • r ⇒ Beschränkt die Ausgabe auf laufende Prozesse.
  • –deselect ⇒ negative Auswahl.
  • -C prozess ⇒ Ausgabe aller instanzen des Prozesses.
  • -U benutzer ⇒ zeigt alle Prozesse eines Users an.
  • -g ⇒ Auswahl über Gruppennamen.
  • -p ⇒ Auswahl über PID.
  • -s ⇒ Wählt Prozesse, die zur angegebenen Session gehören.
  • -t ⇒ Auswahl über tty.
  • -u ⇒ Auswahl über userID (unterstützt auch Namen).


Optionen Ausgabeformat:

  • -f ⇒ Ausgabe komplett.
  • -j ⇒ Jobs Format.
  • -l ⇒ Langes Format.
  • -y ⇒ keine Flags anzeigen.
  • -O ⇒ wird vor o geladen.
  • X ⇒ altes Linux-i386 Register Format.
  • s ⇒ Signal Format.
  • -H ⇒ zeigt Prozesshierarchie.
  • -m ⇒ zeigt Threads.
  • C ⇒ Reine CPU-Zeit für %CPU anzeigen anstatt des Durchschnittswerts.
  • c ⇒ tatsächlichen Befehlsnamen anzeigen.
  • e ⇒ Umgebung nach dem Befehl anzeigen.
  • f, –forest ⇒ Prozesshierarchie als ASCII-Kunst (Wald).
  • –html ⇒ HTML Ausgabe.
  • –sort ⇒ Sortierreihenfolge angeben.
  • -o ⇒ Benutzerdefiniertes Format. Hier kann die Ausgabe der Spalten festgelegt werden.
    • pcpu → Cpu Nutzung.
    • group → Gruppenzugehörigkeit.
    • ppid → Elternprozessid.
    • user → Eigentümer.
    • args → Parameter beim Programmaufruf.
    • comm → Name des Prozesses.
    • nice → Nice Priorität.
    • pid → Prozess ID.
    • pgid → Prozess Gruppen ID.
    • time → verbrauchte Rechenzeit.
    • tty → benutztes Terminal.
    • ruser → relativer Benutzer.
    • rgroup → relative Gruppe.


Optionen der verschiedenen Arten dürfen beliebig gemischt werden. „ps“ ohne Optionen gibt nur die Prozesse aus, die im aktuellen Terminal laufen.

Beispiele:

Ohne Optionen.

root@debian:~# ps
  PID TTY          TIME CMD
 6260 pts/0    00:00:00 bash
 7174 pts/0    00:00:00 ps




Alle Prozesse nach User ID und Prozesse die nicht an Terminal gebunden sind.

root@debian:~# ps aux
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root         1  0.0  0.1   2100   684 ?        Ss   12:43   0:02 init [2]  
root         2  0.0  0.0      0     0 ?        S<   12:43   0:00 [kthreadd]
root         3  0.0  0.0      0     0 ?        S<   12:43   0:00 [migration/0]
...
...
7175 pts/0    R+     0:00 ps aux

Die Spalte „STAT“ zeigt den nice - Wert eines Prozesses an. Wenn ein Prozess „nice“ ist wird ein (N) in der Spalte angezeigt, bei erhöhter Priorität ein (<), (S) interruptible Sleep und (+) Prozess wird im Vordergrund ausgeführt. Für die tatsächliche Feststellung der Priorität kann man auch das Programm „top“ verwenden.


Alle Prozesse aus Liste ausgeben, jedoch nur die Spalten User, Prozess ID, Prozess Name und Terminal des Prozesses.

user@home:~$ ps -eo "user pid comm tty"
USER       PID COMMAND         TT
root         1 init            ?
root         2 kthreadd        ?
root         3 migration/0     ?
root         4 ksoftirqd/0     ?
root         5 watchdog/0      ?


Weitere Infos siehe nice oder top.



pstree


Zeigt Prozesse in einem ASCII Baumdiagramm an.


Beispiel:

user@home:~# pstree
init─┬─acpid
     ├─apache2───10*[apache2]
     ├─atd
     ├─cron
      ...



Optionen:

  • -a ⇒ zeigt die dem Prozess angegebenen Parameter mit an.
  • -G ⇒ VT100 Modus, Optisch schönere Ausgabe.
  • -p ⇒ zeigt PID an.
  • -u ⇒ mit userID.
  • -n ⇒ Ausgabe sortiert nach PIDs.
  • -h ⇒ highlight für laufende Prozesse.
  • -Z ⇒ (SELinux) zeigt Sicherheitscontext der Prozesse (funktioniert nur wenn pstree mit SELinux support kompiliert wurde).





pidof


PID(s) von laufenden Programm mit Programmnamen ermitteln. Programme können mehrere Prozesse starten, diese werden alle aufgelistet.


Syntax:

  • pidof [Optionen] Programm [Programm2 …]



Optionen:

  • -s ⇒ nur eine PID ausgeben.
  • -o <pid> ⇒ nur PIDs werden nicht mit ausgeben.



Beispiele:

root@home:~# pidof apache2
1676 1571 1565 1563 1562 908 907 906 905 903 834




pidof mit anderen Befehlen kombinieren. nice-Wert aller Prozesse von vi ändern.

root@home:~# renice -10 $(pidof vi)


Hat man einem Programm den selben Namen wie einen Prozess gegeben, wird die Prozess ID mit ausgegeben. Dies kann man verhindern in dem man den Dateipfad zum Prozess mit an pidof übergibt.





top


Mit dem Programm „top“ kann man laufende Prozesse in Echtzeit überwachen. Die Prozesse werden dabei dynamisch im Terminal ausgegeben. Es können beim Aufruf und zur Laufzeit Optionen übergeben werden.


top.jpg


In der ersten Zeile des Headers befindet sich die aktuelle Systemzeit, die Laufzeit des Systems (up), die Anzahl der angemeldeten Benutzer (x users), die durchschnittliche Anzahl der Prozesse, die auf die Abarbeitung durch die CPU warten.
Die zweite Zeile zeigt die Anzahl der Prozesse und deren Status an.
Die dritte Zeile zeigt die Verteilung der Rechenzeit an den Userspace (user), den Kernelspace (system), die verwendete Priorität (nice) und (idle) zeigt an, wie viel Prozent der Zeit der Prozessor nicht ausgelastet ist.
Die nächsten beiden Zeilen (4+5) zeigen Informationen über den Physikalischen Hauptspeicher und Swap an. Dabei gibt (total) den maximal verfügbaren Speicher, (used) den davon benutzten Teil und (free) den freien Speicherplatz aus.

Prozesse können verschiedene Stadien annehmen. Im Bild oben (S) in der achten Spalte wird der Status angezeigt. R = running, S = sleeping, T = stopped.

Interaktive Optionen:

  • k ⇒ tötet einen Prozess (kill) es muss die PID und das Signal angegeben werden.
  • n ⇒ Anzahl der Zeilen von top.
  • r ⇒ renice, ändert den Nicewert des Prozesses.
  • h ⇒ gibt eine Hilfe aus (z.B. Interaktive Steuertasten).
  • q ⇒ Beendet das Programm.
  • N ⇒ aufsteigende Sortierung nach PID.
  • A ⇒ aufsteigend nach Alter.
  • P ⇒ absteigend nach CPU Nutzung.
  • M ⇒ absteigend nach Speichernutzung.
  • T ⇒ absteigend nach Beanspruchung der CPU Zeit.

Kommandozeilenoptionen:

  • -i ⇒ zeigt nur aktive Prozesse.
  • -b ⇒ kann mit > (redirector) Ausgabe in eine Textdatei umleiten.
  • -d ⇒ delay Aktualisierungsintervall.
  • -q ⇒ Echtzeitausgabe (Achtung!).


htop ist eine weiterentwicklung von top und bietet mehr Features und Mausunterstützung.





fuser


Ermitteln welche Programme auf Verzeichnisse und Dateien zurückgreifen kann man mit fuser. Ein Verzeichnis gilt als zugegriffen, wenn ein Programm darin gestartet wurde.

user@home:~$ fuser -v /tmp
                     BEN.        PID ZUGR.  BEFEHL
/tmp:                root     kernel mount /tmp
                     tf         2484 ..c.. seahorse-agent



Optionen:

  • -a ⇒ zeigt auch ungenutzte Dateien an.
  • -k ⇒ beendet Prozesse die auf Datei (Verzeichnis) zugreifen.
  • -l ⇒ listet die Signalnamen auf.
  • -m ⇒ zeigt alle Prozesse an, die auf die angegebenen Dateisysteme zugreifen.
  • -M ⇒ Operation nur durchführen, wenn NAME ein Einhängepunkt ist.
  • -n ⇒ suche in angegebenem Namensraum (file, udp oder tcp).
  • -SIGNAL ⇒ sende 'SIGNAL' anstatt SIGKILL.
  • -u ⇒ zeigt BenutzerIds an.
  • -v ⇒ ausführliche ausgabe.
  • -V ⇒ zeigt Versionsinformationen an.
  • -4 ⇒ suche nur IPv4-Sockets.
  • -6 ⇒ suche nur IPv6-Sockets.
  • - ⇒ Optionen zurücksetzen


Ein Dateizugriff kann nur ermittelt werden, wenn das Programm die Datei geöffnet hat.





pgrep


Das Kommando „pgrep“ durchsucht die Liste der laufenden Programme und gibt die PID evtl. auch den Namen auf STDOUT aus. Hierbei müssen alle Auswahlkriterien zutreffen. Es können dabei auch reguläre Ausdrücke benutzt werden.


Syntax:

  • pgrep [Optionen] [Prozessname]



user@home:~$ pgrep nautilus
2518
user@home:~$ pgrep naut
2518



Wird pgrep ohne Optionen ausgeführt, werden alle Prozesse gefunden die den Begriff(Prozessname) beinhalten.



Optionen:

  • -c ⇒ Anzahl der laufenden Prozesse statt der PID.
  • -d<delim> ⇒ Standardmäßig wird eine PID pro Zeile ausgegeben. Durch einen Delimiter kann man dies ändern.
  • -f ⇒ Nicht nur Prozessname, sonder gesamte Kommandozeile Inclusive aller Argumente durchsuchen.
  • -l ⇒ PID, Prozessname mit Pfad wird ausgegeben.
  • -v ⇒ Negiert die Suche.
  • -x ⇒ Sucht nur nach Prozessen mit genau diesen Begriff.
  • -n ⇒ Sucht nur den zuletzt gestarteten Prozess.
  • -o ⇒ Sucht nur den zuerst gestarteten Prozess.
  • -P <PID> ⇒ Sucht nur nach Prozessen, deren Elternprozess die <PID> haben.
  • -U <userid>,<username> ⇒ Sucht nach Prozessen der realen user ID. Dabei kann die UserID oder der Username verwendet werden.
  • -G <gid>,<gname> ⇒ Sucht nach Prozessen der realen Gruppenid gid.



Beispiele:

user@home:~$ pgrep -c sy
3


user@home:~$ pgrep sy
10
12
1438


user@home:~$ pgrep -d: sy
10:12:1438


user@home:~$ pgrep -f sy
10
12
1438
1483
2535


user@home:~$ pgrep -fd: sy
10:12:1438:1483:2535


user@home:~$ pgrep -fl sy
10 async/mgr
12 sync_supers
1438 /usr/sbin/rsyslogd -c4
1483 /usr/bin/dbus-daemon --system
2535 python /usr/bin/system-config-printer-applet


user@home:~$ pgrep -P1 -d:
377:1251:1263:1438:1483:1492:1497:1508:1516:1527:1547:1559:1569:1738:1756:1764:2030:2073:2142:2234:2320:2321:2322:2323:2324:2325:2340:2344:2347:2408:2470:2471:2484:2486:2491:2503:2508:2511:2514:2517:2520:2536:2538:2552:2553:2554:2555:2556:2570:2573:2580:2591:2630:2905:2912:2971:3433:3878:3883:3959:3961





PID Dateien


Einige Hintergrundprozesse speichern Dateien in „/var/run/*.pid“. Diese Datei enthält in der ersten Zeile die Prozessnummer. Durch „pid“ Dateien ist es möglich bestimmte Prozesse durch ein Init-V-Script zu beenden.




kill


Das Kommando kill kann 64 Signale an einen Prozess senden. Siehe Verwaltung von Vorder und Hintergrundprozesse.
Als Argument erwartet „kill“ eine, oder durch Leerzeichen getrennte „PIDs“. Ohne Optionen sendet „kill“ das Signal 15(SIGTERM) an den Prozess. Die PID kann durch ps ermittelt werden (ps -ax | grep apache2).


Syntax:

  • kill [signal] <PID>



Beispiele:

kill -1 2367

oder:

kill -SIGHUP `cat /var/run/dhcpd.pid`


Mit dem cat Befehl wird die PID von dhcpd ermittelt. Die Backticks(``) sorgen dafür, dass die PID an kill -SIGHUP angehängt wird.

Andere Variante:

kill -SIGHUP $(cat /var/run/dhcpd.pid)





pkill


Will man gefundenen Prozessen ein Signal senden, kann man dies mit „pkill“ tun. Im Prinzip verwendet „pkill“ die gleichen Optionen wie pgrep, was hinzukommt ist ein Signal ähnlich wie bei „kill“.

Hier werden allen Instanzen von ssh das SIGHUP Signal geschickt.

pkill -SIGHUP ssh



Alle Prozesse des Benutzers <user> werden abgebrochen.

pkill -9 -u <user>





killall


Mit „killall“ werden keine PIDs verwendet, sondern der Prozessname, es werden alle Prozesse mit dem Namen beendet.


Syntax:

  • killall [Signal] [opt.] [name]


killall -9 mc


Einige Signale:

  • -15 (SIGTERM) → Prozess beenden und Aufräumen.
  • -9 (SIGKILL) → Sofort beenden.
  • -1 (SIGHUB) → Prozess liest seine Initialisierung neu ein, bleibt aber an.



Optionen:

  • -r ⇒ Prozessnamen können durch reguläre Ausdrücke gefiltert werden.
  • -w ⇒ gibt den Prozess 1s Zeit zum beenden.
  • -l ⇒ listet alle Bekannten Signalnamen auf (HUP INT QUIT ILL TRAP ABRT IOT BUS FPE KILL USR1 SEGV PIPE ALRM TERM …).
  • -u [user] ⇒ beendet alle Prozesse, die einen bestimmten User gehören.
  • -s [signal] ⇒ ein bestimmtes Signal (z.B. 9) zum beenden des Prozesses senden.
  • -i ⇒ nachfragen, bevor der Prozess beendet wird.
  • -v ⇒ Verbose.
  • -V ⇒ Version.





xkill


Mit dem „xkill“ Aufruf in der Shell kann man danach mit der Maus das Programmfenster Anklicken und es wird mit dem Signal 9 beendet. Es kann dabei vorkommen, dass „xkill“ zwar das Fenster schließt, jedoch Programmteile weiterlaufen. Es ist daher ratsam nochmal zu überprüfen ob alle Prozesse beendet wurden.




Außer den Runlevel wechsel mit (init) gibt es noch Methoden, das System Herunterzufahren oder Neuzustarten.


  • shutdown
  • halt
  • reboot
  • poweroff




Syntax:

  • shutdown [opt] [wann]



Optionen:

  • -r ⇒ (reboot) Neustart.
  • -h ⇒ Herunterfahren (Linux ).
  • -p ⇒ Herunterfahren (BSD ).
  • -t ⇒ (time) in Sekunden. Funktioniert nicht auf allen Systemen.
  • -k [text] ⇒ Sendet Konsolenmeldungen. Fährt System aber nicht herunter.
  • -f ⇒ Kein fsck beim Neustart durchführen.
  • -F ⇒ fsck beim Neustart erzwingen.



Beispiele:

root@home:~# shutdown -h now

System fährt sofort herunter. Eine Broadcast Meldung wird ausgegeben.


root@home:~# shutdown -rF now

Neustart des Systems. Dateisystemprüfung mit fsck durchführen.


root@home:~# shutdown -h 23:59

System fährt um 23:59 Uhr herunter.




Der Scheduler ist dafür zuständig, den nächsten abzuarbeitenden Prozess auszuwählen. Linux unterscheidet dabei zwischen statischen und dynamischen Prioritäten. Jedem Prozess ist eine Statische Priorität zugeordnet, die über Syscalls verändert werden kann.
Der Scheduler verwaltet eine Liste(Wait Queue) mit statischen Prioritäten von 0 - 99. Es wird dann der nächste abzuarbeitende Prozess aus der ersten nicht leeren Liste mit der höchsten Priorität ausgewählt. Die Scheduling Policy legt dann für jeden Prozess fest, wo die statische Priorität in der Liste wieder eingeordnet wird.



SCHED_OTHER


Die Policy „SCHED_OTHER“ gilt für alle Prozesse mit der statischen Priorität (0), die keine besonderen Erweiterungen für die Echtzeit benötigen. Dabei wird das Zeitscheibenverfahren genutzt, in dem jeden Prozess eine Zeitdauer zur Verfügung gestellt wird und nach Ablauf ein anderer Prozess arbeiten darf.

Nach diesen Verfahren arbeiten auch die dynamischen Prioritäten (nice). Über sie wird die „Fairness“ des Schedulings geregelt. Sollte bei der Wahl eines Prozesses ein lauffähiger Prozess übergangen werden, kann seine dynamische Priorität erhöht werden, um ihm beim nächsten mal bessere Chancen geben.



nice


Wenn in der Shell Prozesse mit hoher Rechenleistung gestartet werden, wird versucht, die verfügbare Rechenzeit gerecht an die Prozesse zu verteilen. Manchmal macht es jedoch Sinn, Programme mit einem niedriger oder höheren „nice“ Wert auszustatten. Dies geht mit „nice“ beim Programmstart, oder mit „renice“, um die Priorität eines laufenden zu verändern.


Prozesspriorität und nice-Wert sind nicht das gleiche, mit nice wird nur Einfluss darauf genommen.



Beim Programmstart kann man den nice -Wert eines Programms übergeben. Es gibt nice -Werte von -20(höchste Priorität) bis >19(niedrigste Priorität). Ohne Optionen wird der nice -Wert (0) übergeben.


User dürfen nice-Werte von 0 - 19 vergeben. Nur root darf negative Werte übergeben.




Syntax:

  • nice [OPTION] [BEFEHL [ARGUMENT]]



Optionen:

  • -n [nicewert] ⇒ nice -Wert zwischen -20 und 19 angeben.
  • –help ⇒ Hilfe anzeigen.
  • –version ⇒ Versionsinformationen anzeigen.



Beispiele:

Der „vi“ Editor wird mit positiven nice-Wert 12 (niedrige Priorität) gestartet.

user@home:~$nice -n 12 vi




Vi mit negativen nice-Wert -15 (hohe Priorität starten).

root@home:~#nice -n -15 vi




Vi als Prozess von <user> mit einem nice-Wert von -4 starten.

root@home:~#nice -n -4 -u <user> vi





renice


Mit „renice“ ist es möglich, den nice -Wert eines Prozesses zur Laufzeit zu verändern. Dabei muß die PID des Prozesses angegeben werden.


Syntax:

  • renice <neuer nicewert> [Optionen[Argumente]]



Optionen:

  • -u <user> ⇒ nice-Werte der Prozesse eines Users verändern.
  • -g <gruppen id> ⇒ renice wird auf alle Prozesse der Prozessgruppenid angewandt.
  • -p <PID> ⇒ nice-Wert der Prozesses mit der <PID> verändern.



Beispiele:

Einen laufenden Prozess mit der PID 5309 wird nice-Wert -10 übergeben.

renice -10 -p 5309




Für alle Prozesse des Benutzers <user> wird der nice-Wert auf 5 geändert.

renice 5 -u <user>




Die nice Priorität des Prozesses mit PID 697 und 1366 und alle Prozesse des Benutzers <user> werden auf nice +10 geändert.

renice +10 -p 697 1366 -u <user>




Verändert die Prozesse mit der PID 666 und 42 sowie alle Prozesse die den usern daemon und root gehören auf den nice-Wert +2.

renice +2 666 -u daemon root -p 42



Die PID kann mit top oder ps ermittelt werden.

Auch top mit der Option R kann den nice-Wert eines Prozesses verändern.






Ein von einer Shell gestartetes Programm kann mit „ulimit“ die Speichergröße des Prozesses einschränken.
FIXME



Cloud