Visuell, was mit fork() in einer For-Schleife passiert

Ich habe versucht zu verstehen fork() Verhalten. Diesmal in einem for-loop. Beachten Sie den folgenden Code:

#include <stdio.h>

void main()
{
   int i;

   for (i=0;i<3;i++)
   {
      fork();

      // This printf statement is for debugging purposes
      // getppid(): gets the parent process-id
      // getpid(): get child process-id

      printf("[%d] [%d] i=%d\n", getppid(), getpid(), i);
   }

   printf("[%d] [%d] hi\n", getppid(), getpid());
}

Hier ist die Ausgabe:

[6909][6936] i=0
[6909][6936] i=1
[6936][6938] i=1
[6909][6936] i=2
[6909][6936] hi
[6936][6938] i=2
[6936][6938] hi
[6938][6940] i=2
[6938][6940] hi
[1][6937] i=0
[1][6939] i=2
[1][6939] hi
[1][6937] i=1
[6937][6941] i=1
[1][6937] i=2
[1][6937] hi
[6937][6941] i=2
[6937][6941] hi
[6937][6942] i=2
[6937][6942] hi
[1][6943] i=2
[1][6943] hi

Ich bin ein sehr visueller Mensch, und daher kann ich die Dinge nur durch Diagramme wirklich verstehen. Mein Lehrer sagte, es wären 8 hallo Aussagen. Ich habe den Code geschrieben und ausgeführt, und tatsächlich gab es 8 hallo Aussagen. Aber ich habe es wirklich nicht verstanden. Also habe ich folgendes Diagramm gezeichnet:

Diagramm aktualisiert, um Kommentare widerzuspiegeln 🙂

Beobachtungen:

1. Der übergeordnete Prozess (main) muss die Schleife dreimal durchlaufen. Dann wird printf aufgerufen
2. Bei jeder Iteration der übergeordneten for-Schleife wird eine fork() aufgerufen
3. Nach jedem Aufruf von fork() wird i inkrementiert, und so startet jedes untergeordnete Element eine for-Schleife von i, bevor es inkrementiert wird
4. Am Ende jeder for-Schleife wird “hi” ausgegeben

Hier sind meine Fragen:

• Ist mein Diagramm korrekt?
• Warum sind da zwei Instanzen von i=0 in der Ausgabe?
• Welchen Wert von i wird nach dem fork() auf jedes Kind übertragen? Wenn der gleiche Wert von i übertragen wird, wann hört das “forking” dann auf?
• Ist das immer so 2^n - 1 wäre eine Möglichkeit, die Anzahl der geforkten Kinder zu zählen? Also, hier n=3was bedeutet 2^3 - 1 = 8 - 1 = 7 Kinder, was ist richtig?

Hier ist, wie man es versteht, beginnend mit dem for Schleife.

1. Schleife beginnt im Elternteil, i == 0

2. Elternteil fork()s, Kind 1 erstellen.

3. Sie haben jetzt zwei Prozesse. Beide drucken i=0.

4. Loop wird jetzt in beiden Prozessen neu gestartet i == 1.

5. Eltern und Kind 1 fork()Erstellen der Kinder 2 und 3.

6. Sie haben jetzt vier Prozesse. Alle vier drucken i=1.

7. Loop startet jetzt in allen vier Prozessen neu i == 2.

8. Eltern und Kinder 1 bis 3 alle fork()Erstellen von Kindern 4 bis 7.

9. Sie haben jetzt acht Prozesse. Alle acht drucken i=2.

10. Loop startet jetzt in allen acht Prozessen neu i == 3.

11. Schleife endet in allen acht Prozessen als i < 3 stimmt nicht mehr.

12. Alle acht Prozesse werden gedruckt hi.

13. Alle acht Prozesse werden beendet.

Also bekommst du 0 zweimal gedruckt, 1 viermal gedruckt, 2 8 mal gedruckt, und hi 8 mal gedruckt.

1. Ja das ist richtig. (siehe unten)
2. Nein, i++ wird ausgeführt nach der Anruf von forkweil das so ist for Schleife funktioniert.
3. Wenn alles erfolgreich verläuft, ja. Denken Sie jedoch daran fork könnte schief gehen.

Kleine Erklärung zum zweiten:

for (i = 0;i < 3; i++)
{
   fork();
}

ist ähnlich wie:

i = 0;
while (i < 3)
{
    fork();
    i++;
}

So i in den gegabelten Prozessen (sowohl Eltern als auch Kind) ist der Wert vor dem Inkrement. Das Inkrement wird jedoch unmittelbar danach ausgeführt fork()also meiner Meinung nach könnte das Diagramm als richtig behandelt werden.

Um deine Fragen einzeln zu beantworten:

Ist mein Diagramm korrekt?

Ja, im Wesentlichen. Es ist auch ein sehr schönes Diagramm.

Das heißt, es ist richtig, wenn Sie das interpretieren i=0 usw. Bezeichnungen beziehen sich auf vollständige Schleifeniterationen. Was das Diagramm nicht Show ist jedoch, dass nach jedem fork()der Teil der aktuellen Schleifeniteration nach dem fork() Aufruf wird auch vom gegabelten untergeordneten Prozess ausgeführt.

Warum gibt es zwei Instanzen von i=0 in der Ausgabe?

Denn du hast die printf() nach dem fork(), also wird es sowohl vom übergeordneten Prozess als auch vom gerade gegabelten untergeordneten Prozess ausgeführt. Wenn Sie die verschieben printf() Vor dem fork()wird es nur vom Elternprozess ausgeführt (da der Kindprozess noch nicht existiert).

Welchen Wert von i wird nach dem auf jedes Kind übertragen fork()? Wenn der gleiche Wert von i übertragen wird, wann hört das “forking” dann auf?

Der Wert von i wird nicht verändert durch fork()sodass der untergeordnete Prozess denselben Wert wie sein übergeordneter Prozess sieht.

Die Sache, an die man sich erinnern sollte fork() ist, dass es einmal aufgerufen wird, aber zweimal zurückkehrt – einmal im übergeordneten Prozess und einmal im neu geklonten untergeordneten Prozess.

Betrachten Sie für ein einfacheres Beispiel den folgenden Code:

printf("This will be printed once.\n");
fork();
printf("This will be printed twice.\n");
fork();
printf("This will be printed four times.\n");
fork();
printf("This will be printed eight times.\n");

Der untergeordnete Prozess, der von erstellt wurde fork() ist ein (fast) exakter Klon seines übergeordneten Prozesses und “erinnert” sich daher aus seiner eigenen Sicht daran, sein übergeordneter Prozess zu sein, und erbt den gesamten Status des übergeordneten Prozesses (einschließlich aller Variablenwerte, des Aufrufstapels und der ausgeführten Anweisung). Der einzige unmittelbare Unterschied (abgesehen von Systemmetadaten wie der von zurückgegebenen Prozess-ID getpid()) ist der Rückgabewert von fork()die im untergeordneten Prozess null ist, aber im übergeordneten Prozess ungleich null (eigentlich die ID des untergeordneten Prozesses).

Ist das immer so 2^n - 1 wäre eine Möglichkeit, die Anzahl der geforkten Kinder zu zählen? Also, hier n=3was bedeutet 2^3 - 1 = 8 - 1 = 7 Kinder, was ist richtig?

Jeder Prozess, der a ausführt fork() verwandelt sich in zwei Prozesse (außer unter ungewöhnlichen Fehlerbedingungen, wo fork() könnte daneben gehen). Wenn das Eltern- und das Kind weiterhin denselben Code ausführen (d. h. den Rückgabewert von fork(), oder ihre eigene Prozess-ID, und basierend darauf zu verschiedenen Codepfaden verzweigen), dann verdoppelt jeder nachfolgende Fork die Anzahl der Prozesse. Also, ja, nach drei Forks haben Sie insgesamt 2³ = 8 Prozesse.