Warum gibt ein Programm mit fork () seine Ausgabe manchmal mehrmals aus?

In Programm 1 Hello worldwird nur einmal gedruckt, aber wenn ich es entferne \nund ausführe (Programm 2), wird die Ausgabe 8 Mal gedruckt. Kann mir bitte jemand erklären, welche Bedeutung das \nhier hat und wie sich das auswirkt fork()?

Programm 1

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

int main()
{
    printf("hello world...\n");
    fork();
    fork();
    fork();
}

Ausgang 1:

hello world... 

Programm 2

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

int main()
{
    printf("hello world...");
    fork();
    fork();
    fork();
}

Ausgang 2:

hello world... hello world...hello world...hello world...hello world...hello world...hello world...hello world...

Bei der Ausgabe auf Standardausgabe mit der printf()Funktion der C-Bibliothek wird die Ausgabe normalerweise gepuffert. Der Puffer wird erst geleert, wenn Sie eine neue Zeile ausgeben, fflush(stdout)das Programm aufrufen oder beenden (jedoch nicht durch Aufrufen _exit()). Der Standardausgabestream wird auf diese Weise standardmäßig zeilenweise gepuffert, wenn er mit einem TTY verbunden ist.

Wenn Sie den Prozess in "Programm 2" verzweigen, erben die untergeordneten Prozesse alle Teile des übergeordneten Prozesses, einschließlich des nicht leeren Ausgabepuffers. Dadurch wird der nicht gelöschte Puffer effektiv auf jeden untergeordneten Prozess kopiert.

Wenn der Prozess beendet ist, werden die Puffer geleert. Sie starten insgesamt acht Prozesse (einschließlich des ursprünglichen Prozesses), und der nicht geleerte Puffer wird nach Beendigung jedes einzelnen Prozesses geleert.

Es ist acht, weil Sie bei jedem fork()die doppelte Anzahl von Prozessen erhalten, die Sie vor dem hatten fork()(da sie bedingungslos sind), und Sie haben drei von diesen (2 ³ = 8).

Es beeinflusst die Gabel in keiner Weise.

Im ersten Fall haben Sie 8 Prozesse, bei denen Sie nichts zu schreiben haben, da der Ausgabepuffer (aufgrund der \n) bereits geleert wurde .

Im zweiten Fall haben Sie noch 8 Prozesse, jeder mit einem Puffer, der "Hallo Welt ..." enthält, und der Puffer wird am Ende des Prozesses geschrieben.

@ Kusalananda erklärte, warum die Ausgabe wiederholt wird . Wenn Sie neugierig sind, warum die Ausgabe 8 Mal und nicht nur 4 Mal wiederholt wird (das Basisprogramm + 3 Gabeln):

int main()
{
    printf("hello world...");
    fork(); // here it creates a copy of itself --> 2 instances
    fork(); // each of the 2 instances creates another copy of itself --> 4 instances
    fork(); // each of the 4 instances creates another copy of itself --> 8 instances
}

Der wichtige Hintergrund hierbei ist, dass stdoutdie Leitung standardmäßig gepuffert sein muss .

Dies bewirkt, dass a \nden Ausgang spült.

Da das zweite Beispiel keine neue Zeile enthält, wird die Ausgabe nicht geleert und fork()kopiert als Kopie des gesamten Prozesses auch den Zustand des stdoutPuffers.

Mit diesen fork()Aufrufen in Ihrem Beispiel werden insgesamt 8 Prozesse erstellt - alle mit einer Kopie des Status des stdoutPuffers.

Per Definition rufen alle diese Prozesse exit()bei der Rückkehr von main()und bei exit()Aufrufen fflush()gefolgt von fclose()allen aktiven stdio- Streams auf. Dies schließt ein stdoutund als Ergebnis wird derselbe Inhalt achtmal angezeigt.

Es ist empfehlenswert, vor dem Aufrufen fflush()alle Streams mit ausstehender Ausgabe aufzurufen fork()oder den untergeordneten Zweig explizit aufrufen zu lassen, der _exit()den Prozess nur beendet, ohne die stdio-Streams zu leeren.

Beachten Sie, dass beim Aufrufen exec()die Stdio-Puffer nicht geleert werden. Daher ist es in Ordnung, sich nicht um die Stdio-Puffer zu kümmern, wenn Sie (nach dem Aufrufen fork()) anrufen exec()und (falls dies fehlschlägt) anrufen _exit().

Übrigens: Um zu verstehen, dass eine falsche Pufferung dazu führen kann, ist hier ein früherer Fehler in Linux, der kürzlich behoben wurde:

Der Standard muss stderrstandardmäßig nicht stderrgepuffert sein , aber Linux hat dies ignoriert und die Zeilen gepuffert und (noch schlimmer) vollständig gepuffert, falls stderr über eine Pipe umgeleitet wurde. Programme, die für UNIX geschrieben wurden, gaben also unter Linux Dinge ohne Zeilenumbruch zu spät aus.

Siehe Kommentar unten, es scheint jetzt behoben zu sein.

Folgendes tue ich, um dieses Linux-Problem zu umgehen:

    /* 
     * Linux comes with a broken libc that makes "stderr" buffered even 
     * though POSIX requires "stderr" to be never "fully buffered". 
     * As a result, we would get garbled output once our fork()d child 
     * calls exit(). We work around the Linux bug by calling fflush() 
     * before fork()ing. 
     */ 
    fflush(stderr); 

Dieser Code schadet auf anderen Plattformen nicht, da das Aufrufen fflush()eines gerade gelöschten Streams ein Noop ist.