Caso curioso de ramificação inesperada em fork()

Considere o seguinte trecho de código que emprega a primitiva fork() para criar processos filhos:

#include 
#include 
#include 

int main(void)
{
    int i;
    for(i = 0; i 
Surpreendentemente, a execução deste programa produz oito pontos de saída, seis a mais do que você poderia inicialmente prever. Por que isso ocorre?
Desvendando os processos ocultos
Para desvendar esse mistério, vamos nos aprofundar na operação de fork(). fork() cria uma réplica do processo atual, resultando em um processo pai e um processo filho.
Inicialmente, há um único processo, que se divide em dois. Ambos os processos executam incrementalmente o loop for, imprimindo um ponto a cada vez. Na segunda iteração, cada processo se bifurca novamente, criando um total de quatro processos. Esses quatro processos imprimem um ponto antes de terminar.
Saída em buffer e aparência atrasada
No entanto, printf() armazena em buffer sua saída, o que significa que acumula várias impressões antes de enviá-las. de uma vez. Quando todos os quatro processos imprimem seus segundos pontos, eles são armazenados em buffer. É aqui que surge o efeito sorrateiro.
Em fork(), os pontos armazenados em buffer são herdados pelos processos filhos. Assim, quando cada processo filho termina, seu ponto em buffer aparece no fluxo de saída. Adicionar esses quatro pontos atrasados ​​aos quatro pontos impressos de forma incremental resulta no total inesperado de oito.
Evitando pontos em buffer
Para ignorar esse comportamento em buffer, é aconselhável chamar flush(stdout); após cada instrução printf(). Isso força o envio imediato da saída, garantindo que o número esperado de pontos seja exibido.