Was genau gibt Fork zurück?

Bei Erfolg wird die PID des untergeordneten Prozesses in den Ausführungs-Thread des übergeordneten Prozesses zurückgegeben, und eine 0 wird in den Ausführungs-Thread des untergeordneten Prozesses zurückgegeben.

p = fork();

Ich bin verwirrt über die Handbuchseite, is p gleicht 0 oder PID?

Ich bin mir nicht sicher, wie das Handbuch klarer sein könnte! fork() erstellt einen neuen Prozess, also haben Sie jetzt zwei identisch Prozesse. Zur Unterscheidung ist der Rückgabewert von fork() unterscheidet sich. Im ursprünglichen Prozess erhalten Sie die PID des untergeordneten Prozesses. Im untergeordneten Prozess erhalten Sie 0.

Eine kanonische Verwendung ist also wie folgt:

p = fork();
if (0 == p)
{
    // We're the child process
}
else if (p > 0)
{
    // We're the parent process
}
else
{
    // We're the parent process, but child couldn't be created
}

                             p = fork();
                        /* assume no errors */
                        /* you now have two */
                        /* programs running */
                         --------------------
      if (p > 0) {                |            if (p == 0) {
        printf("parent\n");       |              printf("child\n");
        ...                       |              ...

Prozesse sind strukturiert in a gerichteter Baum wo du nur deinen alleinerziehenden elternteil kennst (getppid()). Zusamenfassend, fork() kehrt zurück -1 Bei einem Fehler ist wie bei vielen anderen Systemfunktionen ein Wert ungleich Null für den Initiator des Fork-Aufrufs (den Elternteil) nützlich, um seine neue Kind-PID zu kennen.

Nichts ist so gut wie Beispiel:

/* fork/getpid test */
#include <sys/types.h>
#include <unistd.h>     /* fork(), getpid() */
#include <stdio.h>

int main(int argc, char* argv[])
{
    int pid;

    printf("Entry point: my pid is %d, parent pid is %d\n",
           getpid(), getppid());

    pid = fork();
    if (pid == 0) {
        printf("Child: my pid is %d, parent pid is %d\n",
               getpid(), getppid());
    }
    else if (pid > 0) {
        printf("Parent: my pid is %d, parent pid is %d, my child pid is %d\n",
               getpid(), getppid(), pid);
    }
    else {
        printf("Parent: oops! can not create a child (my pid is %d)\n",
               getpid());
    }

    return 0;
}

Und das Ergebnis (bash ist in diesem Fall pid 2249):

Entry point: my pid is 16051, parent pid is 2249
Parent: my pid is 16051, parent pid is 2249, my child pid is 16052
Child: my pid is 16052, parent pid is 16051

Wenn Sie einige Ressourcen (Dateien, Eltern-PID usw.) zwischen Eltern und Kind teilen müssen, schauen Sie sich an clone() (für die GNU C-Bibliothek und vielleicht andere)

Einmal fork ausgeführt wird, haben Sie zwei Prozesse. Der Aufruf gibt an jeden Prozess unterschiedliche Werte zurück.

Wenn Sie so etwas tun

int f;
f = fork();
if (f == 0) {
  printf("I am the child\n");
} else {
  printf("I am the parent and the childs pid is %d\n",f);

}

Sie werden beide Meldungen gedruckt sehen. Sie werden durch zwei getrennte Prozesse gedruckt. Auf diese Weise können Sie zwischen den beiden erstellten Prozessen unterscheiden.

Das ist der coole Teil. Es ist gleich BEIDE.

Nicht wirklich. Aber einmal fork kehrt zurück, Sie haben jetzt zwei Kopien Ihres laufenden Programms! Zwei Prozesse. Man kann sie sich als alternative Universen vorstellen. In einem ist der Rückgabewert 0. In der anderen ist es die ID des neuen Prozesses!

Normalerweise haben Sie so etwas:

p = fork();
if (p == 0){
    printf("I am a child process!\n");
    //Do child things
}
else {
    printf("I am the parent process! Child is number %d\n", p);
    //Do parenty things
}

In diesem Fall werden beide Zeichenfolgen gedruckt, aber durch unterschiedliche Prozesse!

fork() wird im übergeordneten Prozess aufgerufen. Dann wird ein untergeordneter Prozess erzeugt. Bis der untergeordnete Prozess spawnt, fork() hat seine Ausführung beendet.

An dieser Stelle, fork() ist zur Rückgabe bereit, gibt jedoch einen anderen Wert zurück, je nachdem, ob es sich um das übergeordnete oder das untergeordnete Element handelt. Im untergeordneten Prozess gibt es 0 zurück, und im übergeordneten Prozess/Thread gibt es die Prozess-ID des untergeordneten Prozesses zurück.

Fork erstellt einen doppelten Prozess und einen neuen Prozesskontext. Wenn es einen 0-Wert zurückgibt, bedeutet dies, dass ein untergeordneter Prozess ausgeführt wird, aber wenn es einen anderen Wert zurückgibt, bedeutet dies, dass ein übergeordneter Prozess ausgeführt wird. Normalerweise verwenden wir eine Wait-Anweisung, damit ein untergeordneter Prozess abgeschlossen wird und der übergeordnete Prozess mit der Ausführung beginnt.