Jedes laufende Programm ist aus Linux-Sicht ein eigener Prozess. Neben dem Prozesskonzept gibt es aber noch den Begriff “Job”: Den nutzt die Shell für Prozesse, die sie in Ihrem Auftrag startet – und diese Jobs können Sie mit Shell-eigenen Befehlen beeinflussen.

Über die Prozessverwaltung mit Kommandozeilentools wie ps, top und kill haben wir zuletzt 2012 geschrieben [1], aber neben Prozessen können Sie auch “Jobs” verwalten: So nennt die Shell alle Prozesse, die Sie durch Befehlseingaben aus ihr heraus starten. Arbeiten Sie parallel in mehreren Shells, sind die Jobs dieser Shells voneinander getrennt.

Eine Übersicht aller zur Shell gehörenden Jobs erhalten Sie mit dem Kommando jobs, das am Anfang jeder Zeile eine Job-Nummer, den Status und den Befehl anzeigt:

esser@easy:~$ jobs
[2]-  Läuft     xeyes &
[3]+  Läuft     nedit artikel.txt &

Haben Sie aus einer Shell heraus noch keine weiteren Programme gestartet (oder diese alle bereits beendet), ist die Liste leer: Es gibt dann keine Jobs. Ansonsten beginnt die Nummerierung immer bei 1, “fehlende” Nummern (wie im Beispiel) bedeuten, dass Jobs schon wieder beendet wurden. Wenn Sie alle Jobs beenden und dann neue starten, fängt die Zählung wieder von vorne (mit Job-Nummer 1) an.

Das Tool kann neben den Job-Nummern auch die Prozessnummern anzeigen, dazu rufen Sie es mit der Option -l auf:

esser@easy:~$ jobs -l
[2]- 18800 Läuft     xeyes &
[3]+ 18807 Läuft     nedit artikel.txt &

Hinten und vorn

Welche Vorteile hat das Job-Konzept im Vergleich zur einfachen Betrachtung der Prozesse? Einer der interessantesten Punkte ist die Möglichkeit, Jobs in den Vordergrund oder in den Hintergrund zu schieben. Ein Programm, das (aus Sicht der Shell) im Vordergrund läuft, blockiert diese Shell: Sie können dort dann keine weiteren Befehle eingeben. Der Begriff kommt aus der Zeit, als es noch keine grafischen Oberflächen gab. Damals waren Vordergrundprogramme eben normale Anwendungen mit Ein- und Ausgaben, die den Bildschirm benutzten – und damit keinen Platz mehr für die Shell ließen. Im Gegensatz dazu waren Hintergrundprogramme solche, die meist ohne Interaktion abliefen, also weder auf Tastatureingaben warteten noch Meldungen im Terminal ausgaben. Unter Linux ist damit heute einfach ein Programm gemeint, das die Shell nicht blockiert.

Schon beim Start eines Programms legen Sie fest, ob es im Vordergrund oder im Hintergrund laufen soll:

• Wenn Sie einfach den Programmnamen eingeben, startet das Programm, und die Shell wartet ab, bis Sie es beenden – erst danach erscheint wieder die Eingabeaufforderung. Das ist ein Vordergrund-Job.
• Setzen Sie hingegen ein kaufmännisches Und-Zeichen (&) hinter den Befehl, starten Sie das Programm im Hintergrund, und es erscheint sofort wieder der Prompt.

Diese Festlegung beim Progammstart ist aber nicht verbindlich; Sie können jederzeit ein Programm aus dem Hintergrund in den Vordergrund oder in anderer Richtung verschieben.

Traditionell war es besonders nützlich, Programme zu unterbrechen und mehrere Jobs in der Shell zu organisieren, weil ein einzelnes (Text-)Terminal immer nur eine Anwendung darstellen konnte. Durch das Job-Management war es dann möglich, mehrere Jobs zu starten und durch Unterbrechen und In-den-Vordergrund-Holen eines anderen Jobs mit fg zwischen diesen Jobs hin- und herzuwechseln. Dieses Feature ist auch heute noch sinnvoll, wenn etwa durch Konfigurationsfehler die grafische Oberfläche eines Linux-Systems nicht startet und Sie im reinen Textmodus landen. Zwar stehen dann über [Alt]+[F1] bis [Alt]+[F6] in der Regel sechs virtuelle Konsolen bereit, an denen Sie sich anmelden und verschiedene Textmodusprogramme starten können (Abbildung 1), was für die meisten Aufgaben ausreicht – aber falls es einmal mehr als sechs Anwendungen sein müssen, können Sie auf die alte Job-Methode zurückgreifen.

Abbildung 1: Wenn die grafische Oberfläche streikt, bleiben noch die über [Alt]+[F1] bis [Alt]+[F6] erreichbaren virtuellen Terminals im klassischen Weiß-auf-Schwarz-Look.

Verschieben

Wollen Sie ein im Vordergrund laufendes Programm in den Hintergrund schieben, unterbrechen Sie es zunächst mit [Strg]+[Z] – Sie sehen dann wieder den Shell-Prompt und einen Hinweis darauf, welchen Job Sie unterbrochen haben. Er hat die Form

[1]+  Angehalten     nedit artikel.txt

Die vorne stehende Nummer ist die Job-ID, und die benötigen Sie, um den Job nun im Hintergrund weiterlaufen zu lassen. Dazu geben Sie bg %1 ein, wobei Sie die Zahl 1 hinter dem Prozentzeichen durch die angezeigte Job-ID ersetzen. Die Shell quittiert auch das Verschiebemanöver mit einer Meldung:

[1]+ nedit artikel.txt &

und der Job arbeitet weiter. Der Befehl bg ist ein Kürzel für Background (Hintergrund), und Sie können ihn auch ohne Job-ID aufrufen, dann schickt bg den zuletzt gestoppten Job in den Hintergrund.

Um einen Job aus dem Hinter- in den Vordergrund zu holen, zeigen Sie zunächst mit jobs die Jobliste an, finden darüber heraus, welche Job-ID das Programm hat, und geben dann fg %1 ein – wieder mit der richtigen Job-ID anstelle der Eins. fg steht für Foreground (Vordergrund). Nach Eingabe des Befehls erscheint kein neuer Shell-Prompt, weil die Shell jetzt wieder blockiert ist: durch den gerade “nach vorne geholten” Job.

Nicht alle Programme können Sie in den Hintergrund schieben – Anwendungen, die Eingaben über das Terminal erwarten, kommen damit nicht klar. Wenn Sie ein solches Programm unterbrechen und mit bg bearbeiten, hält es gleich wieder an, bleibt also im Zustand “angehalten” (Abbildung 2).

Abbildung 2: Der Editor “vi” ist ein Beispiel für Programme, die nicht im Hintergrund laufen können. “bg” ist dann wirkungslos.

Überraschend terminiert

Führen Sie einmal das folgende Experiment auf Ihrem Linux-Rechner durch:

1. Öffnen Sie ein xterm-Terminalfenster. (Wenn xterm bei Ihnen nicht installiert ist, holen Sie das unter Kubuntu mit sudo apt install xterm und unter OpenSuse mit sudo zypper in xterm nach – bei OpenSuse sollte das Programm vorinstalliert sein.)
2. Starten Sie aus diesem xterm-Fenster heraus ein grafisches Programm, z. B. das Spaßprogramm xeyes (siehe auch die Linux-Tipps in dieser Ausgabe).

Nehmen Sie in Schritt 1 nicht die KDE-Konsole: Sie bringt in aktuellen Versionen zu viel Eigenintelligenz mit und zerstört damit unser Experiment. Ob Sie in Schritt 2 das Programm im Hintergrund (mit &) oder im Vordergrund starten, spielt keine Rolle; wichtig ist nur, dass es separat auf dem Desktop angezeigt wird (Abbildung 3). Schließen Sie dann das Terminalfenster über den X-Knopf – damit verschwinden auch die aufmerksamen Augen.

Abbildung 3: Aus einem “xterm”-Fenster heraus wurde das Programm “xeyes” gestartet – schließt man jetzt das Terminal, verschwinden auch die Augen.

Was ist hier passiert? Durch das Schließen des xterm-Fensters haben Sie auch die darin laufende Shell (bash) beendet – und die schickt standardmäßig an alle laufenden Jobs ein “Terminate”-Signal, also auch an das xeyes-Programm. Prinzipiell kann ein Programm solche Signale abfangen und sich z. B. dafür entscheiden, sie zu ignorieren; das tut xeyes aber nicht und wird darum beendet.

Wenn Sie das Experiment wiederholen, xeyes aus dem Terminalfenster als Hintergrundjob (mit &) starten und dann die Shell mit dem Befehl exit verlassen, bleibt das xeyes-Programm hingegen aktiv: Beim Ausstieg mit exit werden keine Signale verschickt.

Jobs mit Terminal

Anders sieht es aus, wenn Sie einen Job gestartet haben, der ohne das Terminalfenster nicht “weiterleben” kann. Das gilt z. B. für den Editor vi. Starten Sie vi und unterbrechen den Editor dann direkt mit [Strg]+[Z], wird er zu einem “angehaltenen” Job; in der Jobliste taucht er dann wie folgt auf:

esser@easy:~$ jobs
[1]+ Angehalten          vi

Wenn Sie jetzt mit exit versuchen, die Shell zu verlassen, wird Ihr Wunsch zunächst ignoriert; stattdessen erscheint eine Warnung:

esser@easy:~$ exit
exit
Es gibt noch angehaltene Prozesse.

Damit weist die Shell auf den vi-Job hin. Erst wenn Sie ein zweites Mal exit eingeben, beendet sich die Shell – und schießt dabei auch den vi-Job ab, denn der hat ohne das mit der Shell verschwindende Terminalfenster keine Chance mehr, weiter zu funktionieren.

Wollen Sie die Möglichkeit haben, auch Programme wie vi im Hintergrund weiterlaufen zu lassen, obwohl Sie die Shell verlassen, aus der heraus Sie es gestartet haben, können Sie das Programm screen verwenden, das wir zuletzt in Ausgabe 02/2012 besprochen haben [2], Sie müssen es evtl. zunächst installieren:

• Kubuntu-Anwender spielen es über sudo apt install screen ein,
• bei OpenSuse sollte das Paket screen standardmäßig installiert sein, anderenfalls hilft sudo zypper in screen weiter.

Sie starten dann eine screen-Sitzung durch Eingabe von screen, was oberflächlich außer einigen Starthinweisen des Tools nichts ändert. Jetzt können Sie z. B. den vi starten und darin eine Datei bearbeiten. Wollen Sie die Shell schließen, verwenden Sie erst die Tastenkombination [Strg]+[A][D] – damit aktivieren Sie die Detach-Funktion von screen (engl. “detach” = dt. “ablösen”), und die vi-Ansicht verschwindet. Schließen Sie dann das Terminalfenster, lebt vi weiter, wie ein Blick in die Prozessliste mit pstree zeigt:

esser@easy:~$ pstree -ps $(pidof vi)
systemd(1)---screen(18658)---bash(18659)---vi(18675)

Es gibt also immer noch die Bash-Shell, aus der heraus Sie vi gestartet haben, und als Terminal verwendet sie ein Pseudoterminal, das von screen bereitgestellt wird.

Der Clou ist, dass Sie jetzt ein neues Terminalfenster öffnen und darin die screen-Sitzung wiederherstellen können – dazu geben Sie in der Shell den Befehl

screen -r

ein (wobei -r für “reattach”, dt. “wieder verbinden” steht). Dadurch landen Sie wieder in der vi-Ansicht, die Sie vorher verlassen hatten. Dieses Feature von screen ist besonders nützlich, wenn Sie über eine instabile Netzwerkverbindung remote auf einem entfernten Rechner arbeiten: Alle Textmodusanwendungen lassen Sie dann einfach in einer screen-Sitzung laufen – bricht die Verbindung ab, loggen Sie sich später neu ein, führen screen -r aus und setzen die Arbeit in der Sitzung fort. Ähnliche Funktionalität wie screen, aber für grafische Anwendungen, bietet das Xpra-Projekt [3].

Abbruch verhindern

Es gibt neben screen-Sitzungen noch zwei Möglichkeiten, versehentliche Programmabbrüche zu vermeiden: Stellen Sie einem Befehl nohup voran, wird die Shell keine Aufforderung zum Programmende an das gestartete Programm schicken, so dass es auch über die Laufzeit der Shell hinaus weiter arbeiten kann. Als Nebeneffekt werden etwaige Ausgaben des Programms in die Datei nohup.out (im Ordner, aus dem heraus Sie den Befehl eingegeben haben) geschrieben. Da durch das Schließen des Terminalfensters ein darin gestartetes Programm seinen “Standardausgabekanal” verliert, ist das ein praktisches Feature.

Anders sieht es aus, wenn Sie ein Programm bereits gestartet haben: Für eine Umleitung ist es dann schon zu spät, aber zumindest das Beenden des Jobs können Sie verhindern, indem Sie ihn (aus Sicht der Shell) “verstoßen” – so ist zumindest die Übersetzung für den Kommandonamen disown, und seine Funktionalität hat auch etwas damit zu tun: Rufen Sie disown mit einer Job-ID (wie üblich mit vorangestelltem %-Zeichen) auf, entfernt die Shell den Job aus ihrer Job-Liste und wird ihn ab sofort ignorieren, so auch beim Beenden der Shell.

esser@easy:~$ sleep 1000 &
esser@easy:~$ jobs
[1]+  Läuft      sleep 1000 &
esser@easy:~$ disown %1
esser@easy:~$ jobs
esser@easy:~$

Vor dem Schließen der Shell “verstoßen” Sie also einfach die noch verbliebenen Jobs (die weiterlaufen sollen).