Início / coding / Perguntas / 79494942
Accepted
Alphin Thomas
Asked: 2025-03-09 03:44:30 +0800 CST

Por que meu processo bifurcado às vezes substitui dados em um arquivo?

  • 772

Tenho o seguinte código C que grava em um arquivo tanto do processo pai quanto do filho após um fork(). No entanto, a saída em testfile.txtàs vezes é corrompida ou está em uma ordem inesperada.

Estou anexando o código:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>

int main() {
    int fd = open("testfile.txt", O_WRONLY | O_CREAT, 0644);
    if (fd == -1) {
        perror("open");
        return 1;
    }

    if (fork() == 0) { 
        // Child process
        write(fd, "Child\n", 6);
        close(fd);
    } else {
        // Parent process
        write(fd, "Parent\n", 7);
        close(fd);
    }

    return 0;
}

Emitir :

  • O arquivo às vezes contém "Child\nParent\n"e outras vezes"Parent\nChild\n"
  • Em alguns casos, a saída é corrompida ou misturada
  • Eu esperava que cada processo fosse escrito separadamente, mas eles parecem interferir um no outro

Pergunta:

  1. Por que isso está acontecendo?
  2. Como posso garantir gravações corretas e separadas de cada processo?
c

2 respostas

  1. Best Answer

    Abra o arquivo com o sinalizador `O_APPEND` para evitar corrupção:

    A página do manual diz: "O arquivo é aberto no modo append. Antes de cada write(2), o deslocamento do arquivo é posicionado no final do arquivo, como se fosse com lseek(2). A modificação do deslocamento do arquivo e a operação de gravação são realizadas como uma única etapa atômica."

    A ordem de saída não é controlada por este sinalizador.

    • 3

  2. Seus processos pai e filho são executados simultaneamente sem nenhuma medida em vigor para garantir a sincronização da operação de gravação. Isso significa que a ordem das duas gravações será arbitrária e pode variar dependendo de qual processo é agendado primeiro pelo sistema.

    Além disso, as duas operações de gravação podem ocorrer ao mesmo tempo e o conteúdo pode ficar misturado. Isso é tecnicamente impossível em um sistema compatível com POSIX para gravações pequenas como a sua, porque uma operação de gravação deve ser atômica em relação a outros gravadores concorrentes para buffers de até PIPE_SIZEbytes. No entanto, para buffers maiores, é uma possibilidade.

    Se você quiser evitar isso, você terá que usar alguma forma de sincronização. Maneiras comuns de fazer isso são:

    1. Memória compartilhada, onde você pode definir mutexes ou semáforos.
    2. IPC (comunicação entre processos) por vários meios, incluindo outros descritores de arquivo (pipes, sockets, eventfd), sinais, etc.
    3. Bloqueios de arquivo.

    Se você só quer garantir exclusividade mútua (ou seja, sem conteúdo misto, uma gravação será executada completamente antes da outra), então um simples bloqueio de arquivo via flocksyscall é o suficiente. Tecnicamente, isso já deveria ser o caso sem um bloqueio porque, como eu disse acima, essas pequenas gravações devem ser atômicas no Linux.

    Aqui está um exemplo:

    #include <err.h>
#include <sys/file.h>

/* ... */

    if (fork() == 0) {
        // Child process

        // Acquire exclusive lock
        if (flock(fd, LOCK_EX) != 0)
            err(1, "child: flock failed");

        write(fd, "Child\n", 6);

        // Closing automatically releases the lock
        close(fd);
    } else {
        // Parent process

        // Acquire exclusive lock
        if (flock(fd, LOCK_EX) != 0)
            err(1, "parent: flock failed");

        write(fd, "Parent\n", 7);

        // Closing automatically releases the lock
        close(fd);
    }

    Quando um dos dois processos estiver segurando o bloqueio, o outro processo bloqueará a flockchamada, que só será concluída quando o bloqueio for liberado pelo outro processo. Isso garante que as seções críticas entre o flocke o closesejam executadas. Você sempre verá ou Child\nParent\n, Parent\nChild\nnunca algum conteúdo misto.

    Se, em vez disso, você também quiser garantir a ordem das duas operações, você terá que usar algo mais complexo. Um pipe ou um eventfd (este último é somente para Linux) são algumas das ferramentas mais simples que você pode usar para conseguir isso.

    Aqui está um exemplo usando um pipe criado via pipesyscall:

    #include <err.h>
#include <unistd.h>

/* ... */
    
    // Create pipe for communication between parent and child
    int pipefds[2];
    if (pipe(pipefds) != 0)
        err(1, "pipe failed");

    if (fork() == 0) {
        // Child process

        // Wait for parent to write first
        char tmp;
        if (read(pipefds[0], &tmp, 1) != 1)
            err(1, "child: read from pipe failed");

        write(fd, "Child\n", 6);
        close(fd);
    } else {
        // Parent process

        write(fd, "Parent\n", 7);
        close(fd);

        // Signal child that it can now proceed
        if (write(pipefds[1], "x", 1) != 1)
            err(1, "parent: write to pipe failed");
    }

    Neste caso você deve sempre ver Parent\nChild\nem seu arquivo.

    Como nota final: lembre-se de sempre verificar o valor de retorno de fork, writee outras syscalls ou chamadas de função de biblioteca que podem falhar . Uma única writegeralmente não garante que o buffer inteiro seja escrito, mais de uma escrita pode ser necessária.

    • 1

relate perguntas