Perché un programma con fork () a volte stampa il suo output più volte?

Nel Programma 1 Hello worldviene stampato solo una volta, ma quando lo rimuovo \ned eseguo (Programma 2), l'output viene stampato 8 volte. Qualcuno può spiegarmi il significato di \nqui e come influisce fork()?

Programma 1

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

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

Uscita 1:

hello world... 

Programma 2

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

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

Uscita 2:

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

Quando si invia all'output standard usando la printf()funzione della libreria C , l'output è di solito bufferato. Il buffer non viene scaricato fino a quando non viene emessa una nuova riga, non si chiama fflush(stdout)o si esce dal programma (non tramite la chiamata _exit()però). Per impostazione predefinita, il flusso di output standard è bufferizzato in linea in questo modo quando è collegato a un TTY.

Quando si esegue il fork del processo in "Programma 2", i processi figlio ereditano ogni parte del processo padre, incluso il buffer di output non scaricato. Ciò copia efficacemente il buffer non scaricato a ciascun processo figlio.

Al termine del processo, i buffer vengono scaricati. Si avvia un totale complessivo di otto processi (incluso il processo originale) e il buffer non scaricato verrà scaricato alla fine di ogni singolo processo.

Sono otto perché ad ognuno fork()ottieni il doppio del numero di processi che hai avuto prima del fork()(poiché sono incondizionati), e ne hai tre di questi (2 ³ = 8).

Non influisce in alcun modo sulla forcella.

Nel primo caso, si ottengono 8 processi senza nulla da scrivere, poiché il buffer di output è già stato svuotato (a causa di \n).

Nel secondo caso hai ancora 8 processi, ognuno con un buffer contenente "Hello world ..." e il buffer è scritto alla fine del processo.

@Kusalananda ha spiegato perché l'output si ripete . Se sei curioso di sapere perché l'output viene ripetuto 8 volte e non solo 4 volte (il programma di base + 3 forchette):

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
}

Lo sfondo importante qui è che stdoutè richiesto il buffer di linea dallo standard come impostazione predefinita.

Ciò provoca \na svuotare l'output.

Poiché il secondo esempio non contiene la nuova riga, l'output non viene svuotato e, poiché fork()copia l'intero processo, copia anche lo stato del stdoutbuffer.

Ora, queste fork()chiamate nel tuo esempio creano 8 processi in totale, tutti con una copia dello stato del stdoutbuffer.

Per definizione, tutti questi processi chiamano exit()al ritorno da main()e exit()chiamate fflush()seguite da fclose()tutti i flussi stdio attivi . Ciò include stdoute, di conseguenza, viene visualizzato lo stesso contenuto otto volte.

È buona norma chiamare fflush()tutti i flussi con output in sospeso prima di chiamare fork()o lasciare che il bambino biforcato chiami esplicitamente _exit()che esce dal processo solo senza svuotare i flussi stdio.

Nota che la chiamata exec()non scarica i buffer dello stdio, quindi è OK non preoccuparsi dei buffer dello stdio se tu (dopo aver chiamato fork()) chiami exec()e (se ciò fallisce) chiama _exit().

A proposito: per capire che può causare un buffering errato, ecco un ex bug in Linux che è stato corretto di recente:

Lo standard richiede stderrdi non essere bufferizzato per impostazione predefinita, ma Linux lo ha ignorato e ha reso il stderrbuffer di linea e (anche peggio) completamente bufferizzato nel caso in cui stderr fosse reindirizzato attraverso una pipe. Quindi i programmi scritti per UNIX hanno prodotto cose senza newline troppo tardi su Linux.

Vedi il commento qui sotto, sembra essere stato risolto ora.

Questo è quello che faccio per aggirare questo problema con Linux:

    /* 
     * 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); 

Questo codice non danneggia le altre piattaforme poiché la chiamata fflush()su uno stream appena scaricato è un noop.