Galileo Computing < openbook >
Galileo Computing - Bücher zur Programmierung und Softwareentwicklung
Galileo Computing - Bücher zur Programmierung und Softwareentwicklung


'Wie werde ich Unix-Guru' als Buch bestellen
A. Willemer
Wie werde ich UNIX-Guru
I  ANWENDUNG
Know-How für Unix/Linux-User: Einführung, Shell, Befehle, Hilfe, Arbeit mit Dateien, Editoren, Reguläre Ausdrücke, nützliche Tools, Hardware.

II  ADMINISTRATION
Tools, Systemstart, Benutzer verwalten, Hardware konfigurieren, Software installieren, Datensicherung, Tuning, Kernel

III  NETZWERK
Client/Server Systeme, TCP/IP, Routing, IPv6, Internet-Dienste, DHCP, Webserver, Firewalls

IV  DAS X-WINDOW SYSTEM
Die grafische Oberfläche von UNIX einrichten und nutzen

V  PROGRAMMIERUNG VON SHELLSKRIPTEN
Automatisieren von Tasks durch Shell-Skripte.

VI  PERL
Interpreter, Syntax, Variablen, Steuerung, Funktionen, UNIX-Aufrufe, GUIs mit Tk

VII  PROGRAMMIERWERKZEUGE
C-Compiler, Analyse-Tools, CVS, yacc, diff

VIII  UNIX-SYSTEMAUFRUFE
UNIX-Befehle in eigenen Programmen nutzen

IX  LITERATUR
Weiterführende Literatur zu UNIX und LINUX

 
Galileo Computing / <openbook> / "Wie werde ich UNIX-Guru ?"
« Multiprocessing contra Multithreading Prozesse exec und system »

Unterabschnitte
  • Geburt eines Dämons
  • Der unsterbliche Prozess

Vervielfältigen von Prozessen: fork

Ein neuer Prozess entsteht durch den Aufruf von fork(). Er dupliziert den aktuell laufenden Prozess. Anschließend laufen beide Prozesse parallel. Der neue Prozess ist ein Duplikat der Arbeitsumgebung des Vaters, inklusive des Zustands der CPU, des gesamten Speicherzustands sowie aller offenen Dateien.

#include <unistd.h>
pid_t fork(void);

Beide Prozesse stehen nach dem Ausführen des fork() direkt hinter dem Funktionsaufruf und unterscheiden sich nicht. Nur am Rückgabewert des fork() erkennt der jeweilige Prozess, ob er der Vater oder der Sohn ist.

[Prozessteilung durch fork]
int SohnPID;

SohnPID=fork();
  if (SohnPID > 0) {
    /* Der Vater ist hier aktiv */
  } else if (SohnPID == 0) {
    /* Der Sohn ist hier aktiv */
  } else {
    /* das war's wohl: Fehler! */
  }

Diese Konstruktion ist ideal, um Serverprozesse zu implementieren. Sobald eine Anfrage vorliegt, teilt sich der Prozess. Beide Prozesse haben die gleichen Informationen, kennen also den Anfrager und haben die Zugriffe auf die benötigten Dateien. Der Vaterprozess kann also hier die Arbeit ohne Zeitverlust dem Sohn überlassen, die Verbindung zum Anfrager schließen und auf neue Anfragen warten.

Geburt eines Dämons

Wie schon an anderer Stelle erwähnt, ist ein Dämon ein Prozess, der im Hintergrund läuft und auf ein bestimmtes Ereignis wartet. Serverprozesse sind als Dämonen implementiert oder werden von Dämonen gestartet. Wenn ein Prozess im Hintergrund laufen soll, erzeugt er von sich selbst ein Duplikat und endet, so dass nur noch der Sohn läuft. Das Ergebnis ist, dass dem Sohn der Vater fehlt. Das macht den init-Prozess so traurig, dass er den Sohn adoptiert. Der Code ist sehr kurz:

if (fork()!=0) exit(0);

Als weiterer Vorteil gilt, dass der Prozess nicht das SIGHUP-Signal bekommt, falls er von Hand gestartet wurde und der startende Benutzer sich abmeldet. Dieses würde der Vater bekommen. Da der aber nicht mehr lebt...

Der unsterbliche Prozess

In manchen Fällen ist es wichtig, dass ein Prozess zwar aufgrund widriger Umstände auch sterben könnte, aber dann sofort wieder neu erzeugt werden soll. Auch eine solche Konstruktion können Sie mit dem fork leicht erzeugen.

[Unsterblicher Prozess]
for(;;) { /* bis zum nächsten Stromausfall */
    procid = fork();
    if (procid>0) { /* Vater */
        wait(&Zustand);
        /* wenn wir hier sind, ist der Sohn tot */
    } else { /* Sohn */
        for (;;) { /* forever and ever ... */
            /* hier arbeitet der Sohn ewig (fast)... */
        }
    }
}

Der Vaterprozess läuft sofort auf den Aufruf von wait(). Er wartet also, bis der Sohn endet. Da dieser eigentlich endlos arbeiten soll, heißt das, dass der Vaterprozess nur weiterläuft, wenn der Sohn aus welchem Grund auch immer stirbt. Der Vater wiederholt daraufhin die Schleife und kommt wieder zum Aufruf von fork(), erzeugt also wieder einen neuen Sohn.

Muss ein solcher Dämon doch einmal abgeschossen werden, muss natürlich der Vater vor dem Sohn getötet werden.



« Multiprocessing contra Multithreading | Prozesse | exec und system »
 
 Zum Katalog
Zum Katalog
Wie werde ich UNIX-Guru?
bestellen
 Ihre Meinung?
Wie hat Ihnen das <openbook> gefallen?
Ihre Meinung

 UNIX/Linux

PHP 4-Workshop

Einstieg in Python

Perl fürs Web

MySQL 4

GNOME 2.0
 Empfehlung

Einstieg in XML
 Shopping
Versandkostenfrei bestellen in Deutschland und Österreich
Info

 MyGalileo
Der Service für registrierte Leser:
Zu MyGalileo
Info



Copyright © Galileo Press GmbH 2003
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.
[Galileo Computing]

Galileo Press GmbH, Gartenstraße 24, 53229 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, info@galileo-press.de