Question

我有以下问题。

我有两个与信号量同步的进程，其想法是：

进程1将某些内容写入txt文件
进程2将某些内容写入txt文件
进程1将某些内容写入测试文件

我已经包含了演示此问题的示例代码：

// semaphore names 
#define NAME1 "/s1"
#define NAME2 "/s2" 

int main()
{
    /* semaphores for process synchronization */ 
    sem_t *sm1;
    sm1 = sem_open( NAME1, O_CREAT, 0666, 0);

    sem_t *sm2;
    sm2 = sem_open(NAME2, O_CREAT, 0666, 0);

    /* processes*/
    int proc1;
    int proc2;

    /* file lock struct */ 
    struct flock fl = {F_WRLCK, SEEK_SET,   0,      0,     0 };

    /* create a text file */ 
    FILE *fp;
    int fd;

    fp = fopen("output.txt", "w"); // create and close the file 
    fclose(fp);

    if((fd = open("output.txt", O_RDWR)) == -1) { // open the file again to get file descriptor
        perror("open");
        exit(1);
    }

    fp = fdopen(fd, "w");

    /* first process */
    if ((proc1 = fork()) < 0) {
        perror("fork");
        exit(2);
    }
    else if(proc1 == 0) {
        fl.l_type = F_WRLCK; // set the lock type and pid of the forked process 
        fl.l_pid = getpid();

        if (fcntl(fd, F_SETLKW, &fl) == -1) { // lock the file before writing to it 
            perror("fcntl");
            exit(1);
        }

        fprintf(fp, "proc1 - action1\n"); // write to the file

        fl.l_type = F_UNLCK;  

        if (fcntl(fd, F_SETLK, &fl) == -1) {  // unlock the file so other processes can write to it
            perror("fcntl");
            exit(1);
        }

        fprintf(stdout, "proc1 - action1\n"); 

        sem_post(sm1); // let the second process run 
        sem_wait(sm2); // wait till the second process is done 

        // write one more thing the same way to the text file after the second process is done 
        fl.l_type = F_WRLCK;  
        fl.l_pid = getpid();

        if (fcntl(fd, F_SETLKW, &fl) == -1) { 
            perror("fcntl");
            exit(1);
        }

        fprintf(fp, "proc1 - action2\n"); 

        fl.l_type = F_UNLCK;  

        if (fcntl(fd, F_SETLK, &fl) == -1) {  
            perror("fcntl");
            exit(1);
        }

        fprintf(stdout, "proc1 - action2\n"); 

        exit(0);
    }

    /* second process */ 
    if ((proc2 = fork()) < 0) {
        perror("fork");
        exit(2);
    }
    else if(proc2 == 0) {
        sem_wait(sm1); // waits for proc1 to perform it's first action

        // write something to the text file and let proc1 write it's second action 
        fl.l_type = F_WRLCK;  
        fl.l_pid = getpid();

        if (fcntl(fd, F_SETLKW, &fl) == -1) { 
            perror("fcntl");
            exit(1);
        }

        fprintf(fp, "proc2 - action1\n"); 

        fl.l_type = F_UNLCK;  

        if (fcntl(fd, F_SETLK, &fl) == -1) {  
            perror("fcntl");
            exit(1);
        }

        fprintf(stdout, "proc2 - action1\n"); 

        sem_post(sm2);

        exit(0);
    }

    // wait for both processes to finish 
    waitpid(proc1, NULL, 0);
    waitpid(proc2, NULL, 0);

    sem_close(sm1);
    sem_unlink(NAME1);

    sem_close(sm2);
    sem_unlink(NAME2);

    return 0;
}

我已将fprintf包含在stdout行中，以便您可以看到终端中的输出是正确的：

-proc1 - action1
-proc2 - action1
-proc1 - action2

就像他们正在同步一样。但是，output.txt文件中的输出是：

-proc2 - action1
-proc1 - action1
-proc1 - action2

为什么会这样？

此外，在进程写入文件之前，我总是将其锁定，以便其他任何进程都无法访问它，然后再次将其解锁。

我不确定我是否做得对，所以我很感激我能得到的任何建议！

非常感谢！

Answer 1

默认情况下你已经缓冲了IO - 所以缓冲区实际上并没有刷新到文件，直到它关闭它，如果它的输出小于缓冲区大小（否则你一次得到一个缓冲区值）当它满了......通常是8kb左右）。另请注意，每个进程都有自己独立的缓冲区。

要修复，请在打印后刷新输出，然后在写入之前将fseek（）刷新到SEEK_END以确保您位于文件的末尾。

fprintf(fp, "proc1 - action1\n"); // write to the file
fflush(fp);

顺便说一句，我没有检查你的信号量代码的有效性，只是注意到你错过了这条至关重要的信息。但是，一般情况下，如果使用文件锁定，则信号量是多余的......

Answer 2

fp = fopen("output.txt", "w");将截断文件并且未同步，因此即使进程＃1已经向其写入内容，进程＃2也可能截断该文件。 fp = fdopen(fd, "w");

也是如此

此外，如果在另一个进程写入文件时保持文件处于打开状态，则会遇到麻烦。在第二个进程完成写入之后，至少你应该SEEK到文件的（新）端，或者你可以覆盖＃2做的进程。在其他进程运行之前更好地关闭文件，然后重新打开。这也将确保刷新任何缓冲的数据。

错误写入同步进程的文件输出顺序？

2 个答案: