主页 / coding / 问题 / 79494942
Accepted
Alphin Thomas
Asked: 2025-03-09 03:44:30 +0800 CST

为什么我的分叉进程有时会覆盖文件中的数据？

  • 772

我有以下 C 代码，在 之后从父进程和子进程写入文件fork()。但是， 中的输出testfile.txt有时会损坏或出现意外顺序。

我附上了代码：

#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;
}

问题：

  • 文件有时包含"Child\nParent\n"，有时包含"Parent\nChild\n"
  • 在某些情况下，输出被损坏或混杂
  • 我期望每个过程单独写入，但它们似乎互相干扰

问题：

  1. 为什么会发生这种情况？
  2. 我如何确保每个进程的写入正确且独立？
c

2 个回答

  1. Best Answer

    使用标志“O_APPEND”打开文件以避免损坏：

    手册页显示：“文件以追加模式打开。每次写入(2)之前，文件偏移量都位于文件末尾，就像使用 lseek(2) 一样。文件偏移量的修改和写入操作作为单个原子步骤执行。”

    输出顺序不受此标志控制。

    • 3

  2. 您的父进程和子进程同时运行，且未采取任何措施来确保写入操作的同步。这意味着两次写入的顺序将是任意的，并且可能因系统首先调度哪个进程而有所不同。

    此外，两个写入操作可能同时发生，内容可能会混合。对于像您这样的小写入，这在 POSIX 兼容系统上在技术上是不可能的，因为对于最多PIPE_SIZE1000 个字节的缓冲区，写入操作应该与其他并发写入器原子相关。尽管如此，对于较大的缓冲区，这是可能的。

    如果要避免这种情况，则必须使用某种形式的同步。常见的方法是：

    1. 共享内存，您可以在其中定义互斥锁或信号量。
    2. 通过各种方式进行 IPC（进程间通信），包括其他文件描述符（管道、套接字、eventfd）、信号等。
    3. 文件锁。

    如果您只想确保互斥性（即没有混合内容，一个写入将在另一个写入之前完全执行），那么通过flock系统调用进行简单的文件锁定就足够了。从技术上讲，这应该已经是没有锁定的情况了，因为正如我上面所说，这种小的写入在 Linux 上应该是原子的。

    以下是一个例子：

    #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);
    }

    当两个进程中的一个持有锁时，另一个进程将阻塞调用flock，只有当另一个进程释放锁时调用才会完成。这确保了flock和之间的关键部分close得到执行。您将始终看到Child\nParent\n或Parent\nChild\n，永远不会看到混合内容。

    如果您还想保证两个操作的顺序，则必须使用更复杂的东西。管道或 eventfd（后者仅适用于 Linux）是实现此目的的一些最简单的工具。

    下面是一个使用通过系统调用创建的管道的示例pipe：

    #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");
    }

    在这种情况下，您应该始终Parent\nChild\n在您的文件中看到。

    最后要注意的是：一定要检查的返回值fork，write以及其他可能失败的系统调用或库函数调用。单次write写入通常不能保证写入整个缓冲区，可能需要多次写入。

    • 1

相关问题